sneakoscope 4.0.11 → 4.0.13

package/dist/core/providers/glm/naruto/glm-naruto-worker-pool.js

@@ -1,20 +1,18 @@
+import path from 'node:path';
+import { writeJsonAtomic, writeTextAtomic } from '../../../fsx.js';
 import { runPatchWorker } from './glm-naruto-worker-runtime.js';
 import { decideConcurrency } from './glm-naruto-concurrency-governor.js';
-import { planFileLeases } from './glm-naruto-file-lease.js';
 import { evaluateGlmNarutoPatchCandidateGate } from './glm-naruto-patch-candidate-gate.js';
 import { createPatchEnvelope } from './glm-naruto-patch-envelope.js';
 import { writeGlmNarutoWorkerArtifacts } from './glm-naruto-worker-artifacts.js';
 import { materializePatchViaWorktree } from './glm-naruto-worktree-worker.js';
+import { createProviderHealthTracker } from '../../openrouter/openrouter-provider-health.js';
+import { runGlmNarutoWorkerScheduler } from './glm-naruto-worker-scheduler.js';
 export async function runPatchWorkerPool(input) {
     const envelopes = [];
     const traces = [];
     const failedShardIds = [];
     const concurrencyDecisions = [];
-    const shardPathMap = new Map();
-    for (const shard of input.shards) {
-        shardPathMap.set(shard.id, shard.target_paths);
-    }
-    const leases = planFileLeases(shardPathMap);
     const mutableShards = input.shards.filter((s) => s.mutable);
     const decision = decideConcurrency({
         requestedClones: input.maxWorkers,
@@ -24,26 +22,38 @@ export async function runPatchWorkerPool(input) {
         failureRate: 0,
         operatorMax: input.maxWorkers
     });
-    concurrencyDecisions.push(decision);
-    const workerTasks = [];
+    const jobs = [];
     let workerIdx = 0;
     for (const shard of mutableShards) {
         const strategies = input.strategies.get(shard.id) || [shard.strategy];
         for (const strategy of strategies) {
             const workerId = `worker-${shard.id}-${strategy}-${workerIdx++}`;
             const shardWithStrategy = { ...shard, strategy };
-            workerTasks.push(runPatchWorker({
-                apiKey: input.apiKey,
-                missionId: input.missionId,
-                workerId,
-                root: input.cwd,
-                shard: shardWithStrategy,
-                contextSummary: input.contextSummary,
-                timeoutMs: input.workerTimeoutMs
-            }));
+            jobs.push({ worker_id: workerId, shard: shardWithStrategy, strategy });
         }
     }
-    const results = await Promise.allSettled(workerTasks);
+    const health = input.health ?? createProviderHealthTracker();
+    const schedulerResult = await runGlmNarutoWorkerScheduler({
+        jobs,
+        initial_active_workers: decision.target_active_workers,
+        max_active_workers: input.maxWorkers,
+        worker_timeout_ms: input.workerTimeoutMs,
+        health,
+        onDecision: (nextDecision) => {
+            concurrencyDecisions.push(nextDecision);
+        },
+        runJob: (job) => runPatchWorker({
+            apiKey: input.apiKey,
+            missionId: input.missionId,
+            workerId: job.worker_id,
+            root: input.cwd,
+            shard: job.shard,
+            contextSummary: input.contextSummary,
+            timeoutMs: input.workerTimeoutMs
+        })
+    });
+    await writeSchedulerArtifacts(input.cwd, input.missionId, schedulerResult).catch(() => undefined);
+    const results = schedulerResult.results;
     for (const result of results) {
         if (result.status === 'fulfilled' && result.value.ok && result.value.envelope) {
             const isolationMode = input.isolationMode ?? 'patch-envelope-only';
@@ -65,6 +75,9 @@ export async function runPatchWorkerPool(input) {
                     worktree_path: worktree.lease?.path ?? null,
                     branch: worktree.lease?.branch ?? null,
                     base_commit: worktree.lease?.base_commit ?? input.baseCommit ?? null,
+                    candidate_body_sha256: worktree.worktree?.candidate_body_sha256 ?? null,
+                    extracted_patch_sha256: worktree.worktree?.extracted_patch_sha256 ?? null,
+                    applied_patch_was_extracted: worktree.worktree?.applied_patch_was_extracted ?? false,
                     blockers: worktree.blockers
                 };
                 if (!worktree.ok) {
@@ -143,6 +156,35 @@ export async function runPatchWorkerPool(input) {
             failedShardIds.push('unknown');
         }
     }
-    return { envelopes, traces, failedShardIds, concurrencyDecisions };
+    return {
+        envelopes,
+        traces,
+        failedShardIds,
+        concurrencyDecisions,
+        schedulerSummary: {
+            max_observed_active_workers: schedulerResult.max_observed_active_workers,
+            backpressure_events: schedulerResult.backpressure_events,
+            queue_drained: true
+        }
+    };
+}
+async function writeSchedulerArtifacts(root, missionId, schedulerResult) {
+    const dir = path.join(root, '.sneakoscope', 'glm-naruto', missionId);
+    await writeTextAtomic(path.join(dir, 'scheduler-decisions.jsonl'), schedulerResult.decisions.map((decision) => JSON.stringify(decision)).join('\n') + (schedulerResult.decisions.length ? '\n' : ''));
+    await writeJsonAtomic(path.join(dir, 'scheduler-summary.json'), {
+        schema: 'sks.glm-naruto-scheduler-summary.v1',
+        max_observed_active_workers: schedulerResult.max_observed_active_workers,
+        backpressure_events: schedulerResult.backpressure_events,
+        queue_drained: true,
+        result_count: schedulerResult.results.length,
+        decision_count: schedulerResult.decisions.length,
+        retry_count: schedulerResult.retry_events.length
+    });
+    if (schedulerResult.backpressure_records.length > 0) {
+        await writeTextAtomic(path.join(dir, 'provider-backpressure.jsonl'), schedulerResult.backpressure_records.map((row) => JSON.stringify(row)).join('\n') + '\n');
+    }
+    if (schedulerResult.retry_events.length > 0) {
+        await writeTextAtomic(path.join(dir, 'worker-retries.jsonl'), schedulerResult.retry_events.map((row) => JSON.stringify(row)).join('\n') + '\n');
+    }
 }
 //# sourceMappingURL=glm-naruto-worker-pool.js.map

package/dist/core/providers/glm/naruto/glm-naruto-worker-runtime.js

@@ -94,6 +94,7 @@ export async function runPatchWorker(input) {
             ...(input.fetchImpl ? { fetchImpl: input.fetchImpl } : {})
         });
         if (!response.ok) {
+            const issue = classifyWorkerIssue(response.error);
             const trace = { ...traceBase, total_ms: Date.now() - started, status: 'failed', chunk_count: 0, real_stream: false };
             await writeGlmNarutoWorkerArtifacts({
                 root: artifactRoot,
@@ -107,7 +108,8 @@ export async function runPatchWorker(input) {
                 envelope: null,
                 trace,
                 ok: false,
-                error: response.error.code
+                error: response.error.code,
+                issue
             };
         }
         const modelGuard = assertGlm52ActualModel(response.value.model);
@@ -126,7 +128,8 @@ export async function runPatchWorker(input) {
                 envelope: null,
                 trace,
                 ok: false,
-                error: `model_guard:${modelGuard.code}`
+                error: `model_guard:${modelGuard.code}`,
+                issue: { code: `model_guard:${modelGuard.code}`, retryable: false }
             };
         }
         const parsed = parsePatchCandidateOutput(response.value.content);
@@ -153,7 +156,8 @@ export async function runPatchWorker(input) {
                 envelope: null,
                 trace,
                 ok: false,
-                error: parsed.kind
+                error: parsed.kind,
+                issue: { code: parsed.kind, retryable: false }
             };
         }
         const envelope = createPatchEnvelope({
@@ -196,6 +200,7 @@ export async function runPatchWorker(input) {
         return { envelope, trace, ok: true };
     }
     catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
         const trace = { ...traceBase, total_ms: Date.now() - started, status: 'failed', chunk_count: 0, real_stream: false };
         await writeGlmNarutoWorkerArtifacts({
             root: artifactRoot,
@@ -209,10 +214,27 @@ export async function runPatchWorker(input) {
             envelope: null,
             trace,
             ok: false,
-            error: err instanceof Error ? err.message : String(err)
+            error: message,
+            issue: classifyWorkerIssue({ code: message, message, severity: 'failed' })
         };
     }
 }
+function classifyWorkerIssue(issue) {
+    const code = String(issue.code || 'glm_worker_failed');
+    const status = typeof issue.status === 'number' ? issue.status : undefined;
+    const retryable = code === 'glm_openrouter_rate_limited'
+        || status === 429
+        || (typeof status === 'number' && status >= 500)
+        || code === 'glm_openrouter_provider_unavailable'
+        || code === 'glm_stream_idle_timeout'
+        || code === 'glm_request_timeout';
+    return {
+        code,
+        retryable,
+        ...(status !== undefined ? { provider_status: status } : {}),
+        retry_after_ms: null
+    };
+}
 export async function runVerifierWorker(input) {
     const started = Date.now();
     const sessionId = normalizeGlmNarutoSessionId(`sks-glm-naruto-verify-${input.missionId}-${input.workerId}`);

package/dist/core/providers/glm/naruto/glm-naruto-worker-scheduler.js

@@ -0,0 +1,178 @@
+import { nowIso } from '../../../fsx.js';
+import { decideConcurrency } from './glm-naruto-concurrency-governor.js';
+export async function runGlmNarutoWorkerScheduler(input) {
+    const queue = input.jobs.map((job) => ({ job, attempt: 0 }));
+    const running = new Map();
+    const results = [];
+    const decisions = [];
+    const retryEvents = [];
+    const backpressureRecords = [];
+    const maxActive = Math.max(1, input.max_active_workers);
+    let targetActive = Math.max(1, Math.min(maxActive, input.initial_active_workers || 1));
+    let nextRunKey = 0;
+    let maxObservedActive = 0;
+    let backpressureEvents = 0;
+    let failureCount = 0;
+    let finishedCount = 0;
+    let pauseUntilMs = 0;
+    await recordDecision('initial');
+    while (queue.length > 0 || running.size > 0) {
+        const now = Date.now();
+        if (pauseUntilMs > now && running.size === 0) {
+            await sleep(Math.min(1_000, pauseUntilMs - now));
+            continue;
+        }
+        while (queue.length > 0 && running.size < targetActive && Date.now() >= pauseUntilMs) {
+            const entry = queue.shift();
+            const key = nextRunKey++;
+            running.set(key, runTimedJob(key, entry, input));
+            maxObservedActive = Math.max(maxObservedActive, running.size);
+        }
+        if (running.size === 0) {
+            if (queue.length > 0) {
+                targetActive = Math.max(1, targetActive);
+                pauseUntilMs = Math.min(pauseUntilMs || Date.now(), Date.now());
+            }
+            continue;
+        }
+        const completed = await Promise.race([...running.values()]);
+        running.delete(completed.key);
+        finishedCount++;
+        const issue = issueFromSettled(completed.settled);
+        if (completed.settled.status === 'rejected' || (completed.settled.status === 'fulfilled' && !completed.settled.value.ok)) {
+            failureCount++;
+        }
+        updateProviderHealth(input.health, completed.settled);
+        if (issue && shouldBackoff(issue)) {
+            backpressureEvents++;
+            const pauseMs = backoffMs(issue);
+            pauseUntilMs = Math.max(pauseUntilMs, Date.now() + pauseMs);
+            backpressureRecords.push({
+                schema: 'sks.glm-naruto-provider-backpressure.v1',
+                created_at: nowIso(),
+                worker_id: completed.entry.job.worker_id,
+                attempt: completed.entry.attempt,
+                code: issue.code,
+                provider_status: issue.provider_status ?? null,
+                retry_after_ms: issue.retry_after_ms ?? null,
+                pause_ms: pauseMs
+            });
+        }
+        if (shouldRetry(completed.entry, completed.settled, issue)) {
+            const retryEntry = { job: completed.entry.job, attempt: completed.entry.attempt + 1 };
+            retryEvents.push({
+                schema: 'sks.glm-naruto-worker-retry.v1',
+                created_at: nowIso(),
+                worker_id: completed.entry.job.worker_id,
+                shard_id: completed.entry.job.shard.id,
+                next_attempt: retryEntry.attempt,
+                code: issue?.code ?? 'worker_scheduler_rejected'
+            });
+            queue.push(retryEntry);
+        }
+        else {
+            results.push(completed.settled);
+        }
+        await recordDecision(issue?.code ?? 'worker_finished');
+    }
+    return {
+        results,
+        decisions,
+        max_observed_active_workers: maxObservedActive,
+        backpressure_events: backpressureEvents,
+        retry_events: retryEvents,
+        backpressure_records: backpressureRecords
+    };
+    async function recordDecision(reasonSuffix) {
+        const health = input.health.getHealth();
+        const decision = decideConcurrency({
+            requestedClones: maxActive,
+            activeWorkers: targetActive,
+            rateLimited429: health?.count_429 ?? 0,
+            ttftP90Ms: health?.p90_ttft_ms ?? 0,
+            failureRate: finishedCount ? failureCount / finishedCount : 0,
+            operatorMax: maxActive
+        });
+        targetActive = Math.max(running.size > 0 ? 1 : 0, Math.min(maxActive, decision.target_active_workers));
+        if (targetActive === 0 && queue.length > 0 && running.size === 0)
+            targetActive = 1;
+        const recorded = { ...decision, reason: `${decision.reason}:${reasonSuffix}` };
+        decisions.push(recorded);
+        if (recorded.backpressure)
+            backpressureEvents++;
+        await input.onDecision(recorded);
+    }
+}
+async function runTimedJob(key, entry, input) {
+    try {
+        const value = await withTimeout(input.runJob(entry.job), input.worker_timeout_ms);
+        return { key, entry, settled: { status: 'fulfilled', value } };
+    }
+    catch (reason) {
+        return { key, entry, settled: { status: 'rejected', reason } };
+    }
+}
+function updateProviderHealth(health, settled) {
+    if (settled.status !== 'fulfilled') {
+        health.record({ provider_slug: 'openrouter', model: 'z-ai/glm-5.2', count_5xx: 1, last_failure: nowIso() });
+        return;
+    }
+    const issue = settled.value.issue;
+    const trace = settled.value.trace;
+    health.record({
+        provider_slug: trace.provider_slug || 'openrouter',
+        model: trace.model,
+        ...(trace.ttft_ms !== null ? { p50_ttft_ms: trace.ttft_ms } : {}),
+        ...(issue?.provider_status === 429 || issue?.code === 'glm_openrouter_rate_limited' ? { count_429: 1 } : {}),
+        ...(typeof issue?.provider_status === 'number' && issue.provider_status >= 500 ? { count_5xx: 1 } : {}),
+        last_success: settled.value.ok ? nowIso() : null,
+        last_failure: settled.value.ok ? null : nowIso()
+    });
+}
+function issueFromSettled(settled) {
+    if (settled.status === 'rejected') {
+        return { code: 'worker_scheduler_rejected', retryable: true, retry_after_ms: null };
+    }
+    return settled.value.issue ?? null;
+}
+function shouldRetry(entry, settled, issue) {
+    if (entry.attempt >= 1)
+        return false;
+    if (settled.status === 'rejected')
+        return true;
+    return settled.value.ok === false && issue?.retryable === true;
+}
+function shouldBackoff(issue) {
+    return issue.provider_status === 429
+        || issue.code === 'glm_openrouter_rate_limited'
+        || (typeof issue.provider_status === 'number' && issue.provider_status >= 500)
+        || issue.code === 'glm_openrouter_provider_unavailable'
+        || issue.code === 'glm_stream_idle_timeout'
+        || issue.code === 'glm_request_timeout';
+}
+function backoffMs(issue) {
+    if (typeof issue.retry_after_ms === 'number' && Number.isFinite(issue.retry_after_ms) && issue.retry_after_ms > 0) {
+        return Math.min(30_000, issue.retry_after_ms);
+    }
+    if (issue.provider_status === 429 || issue.code === 'glm_openrouter_rate_limited')
+        return 1_000;
+    return 250;
+}
+function withTimeout(promise, timeoutMs) {
+    if (!timeoutMs || timeoutMs <= 0)
+        return promise;
+    let timer;
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error('worker_scheduler_timeout')), timeoutMs);
+        })
+    ]).finally(() => {
+        if (timer)
+            clearTimeout(timer);
+    });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}
+//# sourceMappingURL=glm-naruto-worker-scheduler.js.map

package/dist/core/providers/glm/naruto/glm-naruto-worktree-worker.js

@@ -1,4 +1,6 @@
 import { createPatchEnvelope } from './glm-naruto-patch-envelope.js';
+import { sha256 } from '../../../fsx.js';
+import { parseGlmNarutoPatchCandidate } from './glm-naruto-patch-candidate-parser.js';
 import { applyPatchInWorktree, createGlmNarutoWorkerWorktree, diffWorktree } from './glm-naruto-worktree-manager.js';
 import { cleanupGlmNarutoWorktree } from './glm-naruto-worktree-cleanup.js';
 export async function materializePatchViaWorktree(input) {
@@ -10,10 +12,32 @@ export async function materializePatchViaWorktree(input) {
             workerId: input.envelope.worker_id,
             ...(input.baseCommit !== undefined ? { baseCommit: input.baseCommit } : {})
         });
-        const applied = await applyPatchInWorktree(lease.path, input.envelope.patch);
+        const parsed = parseGlmNarutoPatchCandidate(input.envelope.patch);
+        const parseProof = {
+            candidate_body_sha256: sha256(input.envelope.patch),
+            extracted_patch_sha256: parsed.ok ? sha256(parsed.patch) : null,
+            applied_patch_was_extracted: false
+        };
+        if (!parsed.ok) {
+            await cleanupGlmNarutoWorktree({ repoRoot: input.repoRoot, missionId: input.missionId, lease, cleanup: input.cleanup });
+            return {
+                ok: false,
+                envelope: { ...input.envelope, status: 'gate_failed', blockers: parsed.blockers },
+                lease,
+                blockers: parsed.blockers,
+                worktree: parseProof
+            };
+        }
+        const applied = await applyPatchInWorktree(lease.path, parsed.patch);
         if (!applied.ok) {
             await cleanupGlmNarutoWorktree({ repoRoot: input.repoRoot, missionId: input.missionId, lease, cleanup: input.cleanup });
-            return { ok: false, envelope: { ...input.envelope, status: 'gate_failed', blockers: ['worktree_patch_apply_failed'] }, lease, blockers: ['worktree_patch_apply_failed'] };
+            return {
+                ok: false,
+                envelope: { ...input.envelope, status: 'gate_failed', blockers: ['worktree_patch_apply_failed'] },
+                lease,
+                blockers: ['worktree_patch_apply_failed'],
+                worktree: { ...parseProof, applied_patch_was_extracted: true }
+            };
         }
         const diff = await diffWorktree(lease.path);
         const envelope = createPatchEnvelope({
@@ -21,14 +45,20 @@ export async function materializePatchViaWorktree(input) {
             workerId: input.envelope.worker_id,
             shardId: input.envelope.shard_id,
             baseDigest: input.envelope.base_digest,
-            patch: diff,
+            patch: diff || parsed.patch,
             strategy: input.envelope.strategy,
             reasoningEffort: input.envelope.reasoning_effort,
             status: input.envelope.status,
             warnings: [...input.envelope.warnings, `worktree:${lease.path}`]
         });
         await cleanupGlmNarutoWorktree({ repoRoot: input.repoRoot, missionId: input.missionId, lease, cleanup: input.cleanup });
-        return { ok: true, envelope, lease, blockers: [] };
+        return {
+            ok: true,
+            envelope,
+            lease,
+            blockers: [],
+            worktree: { ...parseProof, applied_patch_was_extracted: true }
+        };
     }
     catch (err) {
         if (lease)

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '4.0.11';
+export const PACKAGE_VERSION = '4.0.13';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "4.0.11",
+  "version": "4.0.13",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",

package/dist/core/providers/glm/glm-bench.js

@@ -1,127 +0,0 @@
-import path from 'node:path';
-import { nowIso, writeJsonAtomic } from '../../fsx.js';
-import { profileFromConst } from './glm-profile-resolver.js';
-import { createEmptyGlmLatencyTrace, writeGlmLatencyTrace } from './glm-latency-trace.js';
-const SYNTHETIC_CASES = Object.freeze([
-    benchCase('small doc edit', 'doc_edit', 420, 980),
-    benchCase('small TS function edit', 'small_edit', 460, 1100),
-    benchCase('failing test fix from small error', 'test_fix', 520, 1220),
-    benchCase('simple config edit', 'config_edit', 390, 930)
-]);
-export async function runGlmBench(root, args = []) {
-    const live = args.includes('--live');
-    const execute = args.includes('--execute');
-    if (execute && !live) {
-        const blocked = {
-            schema: 'sks.glm-bench-result.v1',
-            version: '4.0.9',
-            generated_at: nowIso(),
-            status: 'blocked',
-            dry_run: true,
-            cases: [],
-            summary: {
-                speed_p50_total_ms: 0,
-                speed_p90_total_ms: 0,
-                speed_p50_ttft_ms: null
-            },
-            warnings: ['execute_requested_but_live_openrouter_bench_not_implemented']
-        };
-        await writeJsonAtomic(path.join(root, '.sneakoscope', 'glm', 'bench-blocked.json'), blocked);
-        return blocked;
-    }
-    if (live) {
-        const blocked = {
-            schema: 'sks.glm-bench-result.v1',
-            version: '4.0.9',
-            generated_at: nowIso(),
-            status: 'blocked',
-            dry_run: false,
-            cases: [],
-            summary: {
-                speed_p50_total_ms: 0,
-                speed_p90_total_ms: 0,
-                speed_p50_ttft_ms: null
-            },
-            warnings: ['live_openrouter_bench_requires_explicit_network_runner_not_enabled_in_this_build']
-        };
-        await writeJsonAtomic(path.join(root, '.sneakoscope', 'glm', 'bench-live-blocked.json'), blocked);
-        return blocked;
-    }
-    if (execute) {
-        const blocked = {
-            schema: 'sks.glm-bench-result.v1',
-            version: '4.0.9',
-            generated_at: nowIso(),
-            status: 'blocked',
-            dry_run: true,
-            cases: [],
-            summary: {
-                speed_p50_total_ms: 0,
-                speed_p90_total_ms: 0,
-                speed_p50_ttft_ms: null
-            },
-            warnings: ['execute_requested_without_live_flag_uses_no_network_dry_run_policy']
-        };
-        await writeJsonAtomic(path.join(root, '.sneakoscope', 'glm', 'bench-blocked.json'), blocked);
-        return blocked;
-    }
-    const speedTotals = SYNTHETIC_CASES.map((row) => row.speed.total_ms);
-    const deepTotals = SYNTHETIC_CASES.map((row) => row.deep.total_ms);
-    const result = {
-        schema: 'sks.glm-bench-result.v1',
-        version: '4.0.9',
-        generated_at: nowIso(),
-        status: 'dry_run',
-        dry_run: true,
-        cases: SYNTHETIC_CASES,
-        summary: {
-            speed_p50_total_ms: percentile(speedTotals, 50),
-            speed_p90_total_ms: percentile(speedTotals, 90),
-            speed_p50_ttft_ms: null,
-            deep_p50_total_ms: percentile(deepTotals, 50),
-            speed_vs_deep_ratio: Number((percentile(speedTotals, 50) / percentile(deepTotals, 50)).toFixed(3))
-        },
-        warnings: ['synthetic_dry_run_no_network_no_gpt_key_required']
-    };
-    await writeJsonAtomic(path.join(root, '.sneakoscope', 'glm', 'bench-result.json'), result);
-    await writeGlmLatencyTrace(root, {
-        ...createEmptyGlmLatencyTrace('speed'),
-        total_ms: result.summary.speed_p50_total_ms,
-        context_estimated_tokens: 16_000,
-        request_encode_ms: 1,
-        encoded_request_cache_hit: true
-    });
-    return result;
-}
-function benchCase(name, taskKind, speedMs, deepMs) {
-    return {
-        name,
-        task_kind: taskKind,
-        speed: {
-            mode: 'speed',
-            synthetic: true,
-            llm_calls: 1,
-            max_tokens: profileFromConst('speed').max_tokens,
-            context_target_tokens: 16_000,
-            total_ms: speedMs,
-            ttft_ms: null
-        },
-        deep: {
-            mode: 'deep',
-            synthetic: true,
-            llm_calls: 1,
-            max_tokens: profileFromConst('deep').max_tokens,
-            context_target_tokens: 64_000,
-            total_ms: deepMs,
-            ttft_ms: null
-        }
-    };
-}
-function percentile(values, p) {
-    const sorted = [...values].sort((a, b) => a - b);
-    if (!sorted.length)
-        return 0;
-    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil((p / 100) * sorted.length) - 1));
-    return sorted[index] || 0;
-}
-//# sourceMappingURL=glm-bench.js.map