sneakoscope 4.0.13 → 4.0.15

package/dist/core/providers/glm/bench/glm-bench-model-lock-proof.js

@@ -1,7 +1,10 @@
 import { GLM_52_OPENROUTER_MODEL } from '../glm-52-settings.js';
-export function buildGlmBenchModelLockProof(cases) {
+export function buildGlmBenchModelLockProof(cases, proofInput = {}) {
     const checkedCases = cases.map((c) => c.runner_id);
     const mismatches = [];
+    const requestSummaries = proofInput.requestSummaries ?? [];
+    let fallbackArraysFound = 0;
+    let openaiKeyUsed = false;
     for (const caseResult of cases) {
         if (caseResult.model !== GLM_52_OPENROUTER_MODEL) {
             mismatches.push(`${caseResult.runner_id}: model is ${caseResult.model}, expected ${GLM_52_OPENROUTER_MODEL}`);
@@ -10,13 +13,39 @@ export function buildGlmBenchModelLockProof(cases) {
             mismatches.push(`${caseResult.runner_id}: gpt_fallback_allowed is not false`);
         }
     }
+    for (const summary of requestSummaries) {
+        if (summary.model !== undefined && summary.model !== GLM_52_OPENROUTER_MODEL) {
+            mismatches.push(`request-summary:${String(summary.worker_id ?? summary.runner_id ?? 'unknown')}: model is ${String(summary.model)}`);
+        }
+        const models = Array.isArray(summary.models) ? summary.models : [];
+        const fallbackModelsCount = typeof summary.fallback_models_count === 'number' ? summary.fallback_models_count : models.length;
+        if (fallbackModelsCount > 0)
+            fallbackArraysFound += 1;
+        if (summary.openai_key_used === true || summary.authorization_source === 'openai')
+            openaiKeyUsed = true;
+        if (summary.gpt_fallback_allowed !== undefined && summary.gpt_fallback_allowed !== false) {
+            mismatches.push(`request-summary:${String(summary.worker_id ?? summary.runner_id ?? 'unknown')}: gpt_fallback_allowed is not false`);
+        }
+    }
+    if (fallbackArraysFound > 0)
+        mismatches.push(`fallback_arrays_found:${fallbackArraysFound}`);
+    if (openaiKeyUsed)
+        mismatches.push('openai_key_used');
+    const requestSummaryStatus = requestSummaries.length > 0 ? 'checked' : 'unavailable';
     return {
         schema: 'sks.glm-bench-model-lock-proof.v1',
         checked_cases: checkedCases,
         model: GLM_52_OPENROUTER_MODEL,
         gpt_fallback_allowed: false,
-        fallback_arrays_found: 0,
-        openai_key_used: false,
+        request_summary_status: requestSummaryStatus,
+        request_summaries_checked: requestSummaries.length,
+        request_summaries_unavailable: Math.max(0, cases.length - requestSummaries.length),
+        naruto_request_summaries_checked: requestSummaries.filter((summary) => String(summary.worker_id ?? '').startsWith('worker-')).length,
+        direct_trace_checked: proofInput.directTraceChecked === true,
+        fallback_arrays_found: fallbackArraysFound,
+        openai_key_used: openaiKeyUsed,
+        fallback_array_scan: requestSummaryStatus,
+        openai_key_usage_scan: requestSummaryStatus,
         mismatches,
         passed: mismatches.length === 0
     };

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

@@ -115,19 +115,22 @@ export async function runGlmBenchmark(root, args = [], deps = {}) {
     }
     await cleanupFixture(sharedFixture);
     const comparison = computeGlmBenchmarkComparison(cases);
-    const modelLockProof = buildGlmBenchModelLockProof(cases);
+    const modelLockProof = buildGlmBenchModelLockProof(cases, {
+        requestSummaries: await collectRequestSummaries(cases),
+        directTraceChecked: cases.some((c) => c.runner_id === 'direct-glm-speed' && c.artifacts.trace_path !== null)
+    });
     const userCwdAfter = await captureGitStatus(userCwd);
     const userCwdUnchanged = userCwdBefore === userCwdAfter;
     const noMutationProof = {
         schema: 'sks.glm-bench-no-mutation-proof.v1',
-        user_cwd_unchanged: userCwdUnchanged ? true : true,
+        user_cwd_unchanged: userCwdUnchanged,
         fixture_mutated_only_under_apply_temp: !applyTemp,
         cases_report_no_mutation: true,
         passed: userCwdUnchanged && cases.every((c) => c.mutation_performed === false)
     };
     const result = {
         schema: 'sks.glm-benchmark-result.v1',
-        version: '4.0.13',
+        version: '4.0.15',
         generated_at: nowIso(),
         status: 'live',
         model: GLM_52_OPENROUTER_MODEL,
@@ -154,7 +157,7 @@ export async function runGlmBenchmark(root, args = [], deps = {}) {
 function dryRunResult(root, startedMs) {
     return {
         schema: 'sks.glm-benchmark-result.v1',
-        version: '4.0.13',
+        version: '4.0.15',
         generated_at: nowIso(),
         status: 'dry_run',
         model: GLM_52_OPENROUTER_MODEL,
@@ -177,7 +180,7 @@ function dryRunResult(root, startedMs) {
 function blockedResult(root, warnings) {
     return {
         schema: 'sks.glm-benchmark-result.v1',
-        version: '4.0.13',
+        version: '4.0.15',
         generated_at: nowIso(),
         status: 'blocked',
         model: GLM_52_OPENROUTER_MODEL,
@@ -207,6 +210,27 @@ async function readWorkerTraces(artifactDir) {
         return [];
     }
 }
+async function collectRequestSummaries(cases) {
+    const summaries = [];
+    for (const caseResult of cases) {
+        const dir = caseResult.artifacts.mission_artifact_dir;
+        if (!dir)
+            continue;
+        try {
+            const workerRoot = path.join(dir, 'workers');
+            const workerIds = await fsp.readdir(workerRoot);
+            for (const workerId of workerIds) {
+                try {
+                    const summary = JSON.parse(await fsp.readFile(path.join(workerRoot, workerId, 'request-summary.json'), 'utf8'));
+                    summaries.push(summary);
+                }
+                catch { }
+            }
+        }
+        catch { }
+    }
+    return summaries;
+}
 async function captureGitStatus(cwd) {
     return new Promise((resolve) => {
         const child = spawn('git', ['status', '--short'], { cwd, stdio: ['ignore', 'pipe', 'ignore'] });

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

@@ -1,2 +1,2 @@
-export const GLM_BENCHMARK_VERSION = '4.0.13';
+export const GLM_BENCHMARK_VERSION = '4.0.15';
 //# sourceMappingURL=glm-benchmark-types.js.map

package/dist/core/providers/glm/naruto/glm-naruto-critical-path.js

@@ -0,0 +1,51 @@
+import path from 'node:path';
+import { writeJsonAtomic, writeTextAtomic } from '../../../fsx.js';
+export function buildGlmNarutoCriticalPathMetrics(input) {
+    const stageMs = (stage) => {
+        const matches = input.stages.filter((metric) => metric.stage === stage);
+        if (!matches.length)
+            return null;
+        return matches.reduce((sum, metric) => sum + metric.wall_clock_ms, 0);
+    };
+    const values = {
+        decomposition: input.decompositionMs,
+        patch_generation: stageMs('patch_generation') ?? 0,
+        worktree_materialization: stageMs('worktree_materialization'),
+        candidate_gate: stageMs('candidate_gate') ?? 0,
+        verifier: stageMs('verifier'),
+        conflict_merge: input.conflictMergeMs,
+        final_apply: input.finalApplyMs,
+        final_seal: input.finalSealMs
+    };
+    const slowest = Object.entries(values)
+        .filter(([, value]) => typeof value === 'number')
+        .sort((a, b) => Number(b[1]) - Number(a[1]))[0]?.[0] ?? 'unknown';
+    return {
+        schema: 'sks.glm-naruto-critical-path.v1',
+        total_wall_clock_ms: Math.max(0, input.totalWallClockMs),
+        stage_wall_clock_ms: values,
+        slowest_stage: slowest,
+        parallelism_warnings: input.parallelismWarnings
+    };
+}
+export async function writeGlmNarutoCriticalPathArtifacts(input) {
+    const dir = path.join(input.root, '.sneakoscope', 'glm-naruto', input.missionId);
+    await writeJsonAtomic(path.join(dir, 'critical-path.json'), input.metrics);
+    await writeTextAtomic(path.join(dir, 'speed-diagnosis.md'), renderSpeedDiagnosis(input.metrics));
+}
+function renderSpeedDiagnosis(metrics) {
+    return [
+        '# GLM Naruto Speed Diagnosis',
+        '',
+        `Total wall clock: ${metrics.total_wall_clock_ms}ms`,
+        `Slowest stage: ${metrics.slowest_stage}`,
+        '',
+        '## Stage Wall Clock',
+        ...Object.entries(metrics.stage_wall_clock_ms).map(([stage, ms]) => `- ${stage}: ${ms === null ? 'not_run' : `${ms}ms`}`),
+        '',
+        '## Parallelism Warnings',
+        metrics.parallelism_warnings.length ? metrics.parallelism_warnings.map((warning) => `- ${warning}`).join('\n') : '- none',
+        ''
+    ].join('\n');
+}
+//# sourceMappingURL=glm-naruto-critical-path.js.map

package/dist/core/providers/glm/naruto/glm-naruto-final-seal.js

@@ -12,7 +12,8 @@ export async function writeGlmNarutoFinalSeal(input) {
         secretOk: input.secretAudit.ok,
         mismatches,
         isolationViolations,
-        queueDrained: input.scheduler.queue_drained
+        queueDrained: input.scheduler.queue_drained,
+        requirementCoveragePassed: input.requirementCoverage?.passed ?? true
     });
     const seal = {
         schema: 'sks.glm-naruto-final-seal.v1',
@@ -41,6 +42,12 @@ export async function writeGlmNarutoFinalSeal(input) {
             verifier_passed: input.envelopes.filter((env) => env.verification_passed === true).length,
             selected: input.selectedPatchIds
         },
+        requirement_coverage: {
+            required_total: input.requirementCoverage?.required_total ?? 0,
+            required_covered: input.requirementCoverage?.required_covered ?? 0,
+            passed: input.requirementCoverage?.passed ?? true,
+            uncovered_required_requirements: input.requirementCoverage?.uncovered_required_requirements ?? []
+        },
         apply: {
             attempted: input.applyTransaction !== null,
             transaction_path: input.applyTransaction ? path.join(input.artifactDir, 'apply-transaction.json') : null,
@@ -62,7 +69,7 @@ export async function writeGlmNarutoFinalSeal(input) {
     return { seal, path: out, passed: seal.status === 'passed' };
 }
 function finalSealStatus(input) {
-    if (!input.secretOk || input.mismatches.length > 0 || input.isolationViolations.length > 0 || !input.queueDrained)
+    if (!input.secretOk || input.mismatches.length > 0 || input.isolationViolations.length > 0 || !input.queueDrained || !input.requirementCoveragePassed)
         return 'blocked';
     if (input.result.ok)
         return 'passed';

package/dist/core/providers/glm/naruto/glm-naruto-orchestrator.js

@@ -21,6 +21,11 @@ import { buildGlmNarutoCandidateScoreboard } from './glm-naruto-scoreboard.js';
 import { runGlmNarutoApplyTransaction } from './glm-naruto-apply-transaction.js';
 import { finalizeGlmNarutoTerminal } from './glm-naruto-terminal.js';
 import { writeGlmNarutoFinalSeal } from './glm-naruto-final-seal.js';
+import { runGlmNarutoStageScheduler } from './glm-naruto-stage-scheduler.js';
+import { buildGlmNarutoParallelismSummary, metricFromStageResult, writeGlmNarutoParallelismArtifacts } from './glm-naruto-parallelism-summary.js';
+import { buildGlmNarutoRequirementCoverageSummary, enrichGlmNarutoCandidateRequirementCoverage, inferCandidateRequirementCoverage } from './glm-naruto-requirement-coverage.js';
+import { buildGlmNarutoRequirementLedger } from './glm-naruto-requirement-ledger.js';
+import { buildGlmNarutoCriticalPathMetrics, writeGlmNarutoCriticalPathArtifacts } from './glm-naruto-critical-path.js';
 import { GLM_NARUTO_LIMITS } from './glm-naruto-types.js';
 export async function runGlmNarutoMission(input) {
     const missionId = input.missionId || `glm-naruto-${nowIso().replace(/[:.]/g, '-')}`;
@@ -34,8 +39,15 @@ export async function runGlmNarutoMission(input) {
             result: missionResult(missionId, input.task, 'blocked', 'glm_missing_openrouter_key', 0, startedMs, [], [], ['glm_missing_openrouter_key'], [])
         });
     }
+    const decompositionStartedMs = Date.now();
     const mentionedPaths = extractMentionedPaths(input.task);
     const gitStatus = await readGitStatus(cwd);
+    const requirementLedger = buildGlmNarutoRequirementLedger({
+        missionId,
+        task: input.task,
+        mentionedPaths,
+        ...(gitStatus !== undefined ? { gitStatus } : {})
+    });
     const gitRoot = await getGitRoot(cwd);
     const baseCommit = gitRoot ? await getGitHead(cwd) : null;
     const isolationPolicy = resolveGlmNarutoIsolationPolicy({
@@ -76,6 +88,7 @@ export async function runGlmNarutoMission(input) {
         });
     }
     const laneMix = computeInitialLaneMix(graph);
+    const decompositionMs = Date.now() - decompositionStartedMs;
     const strategies = planShardCandidates(graph);
     const strategyMap = new Map();
     for (const entry of strategies) {
@@ -115,6 +128,8 @@ export async function runGlmNarutoMission(input) {
     let failedShardIds = poolResult.failedShardIds;
     let repairWaves = 0;
     let schedulerSummary = poolResult.schedulerSummary;
+    const stageMetrics = [...poolResult.stageMetrics];
+    const stageEvents = [...poolResult.stageEvents];
     // Repair wave if needed
     if (failedShardIds.length > 0 && repairWaves < GLM_NARUTO_LIMITS.max_repair_waves) {
         const repairPlan = planRepairWave({
@@ -136,9 +151,12 @@ export async function runGlmNarutoMission(input) {
                 isolationMode: isolationPolicy.selected,
                 cleanupWorktrees: input.cleanupWorktrees ?? !input.keepWorktrees,
                 baseCommit,
-                health: healthTracker
+                health: healthTracker,
+                stageName: 'repair_generation'
             });
             envelopes = [...envelopes, ...repairPool.envelopes];
+            stageMetrics.push(...repairPool.stageMetrics);
+            stageEvents.push(...repairPool.stageEvents);
             schedulerSummary = {
                 max_observed_active_workers: Math.max(schedulerSummary.max_observed_active_workers, repairPool.schedulerSummary.max_observed_active_workers),
                 backpressure_events: schedulerSummary.backpressure_events + repairPool.schedulerSummary.backpressure_events,
@@ -156,13 +174,22 @@ export async function runGlmNarutoMission(input) {
     if (passedEnvelopes.length > 0 && !input.skipVerifier) {
         verifierWaveRun = true;
         const verifyApiKey = key.key;
-        const verifyResults = await Promise.allSettled(passedEnvelopes.map((env) => runVerifierWorker({
-            apiKey: verifyApiKey,
-            missionId,
-            workerId: env.worker_id,
-            envelope: env,
-            timeoutMs: 120_000,
-        })));
+        const verifierStage = await runGlmNarutoStageScheduler({
+            stage: 'verifier',
+            jobs: passedEnvelopes.map((env) => ({ id: env.worker_id, stage: 'verifier', input: env })),
+            max_active: Math.min(8, passedEnvelopes.length),
+            timeout_ms: 120_000,
+            runJob: (job) => runVerifierWorker({
+                apiKey: verifyApiKey,
+                missionId,
+                workerId: job.input.worker_id,
+                envelope: job.input,
+                timeoutMs: 120_000,
+            })
+        });
+        stageMetrics.push(metricFromStageResult(verifierStage));
+        stageEvents.push(...verifierStage.events);
+        const verifyResults = verifierStage.results;
         const verifiedEnvelopes = [];
         for (let vi = 0; vi < passedEnvelopes.length; vi++) {
             const env = passedEnvelopes[vi];
@@ -192,8 +219,11 @@ export async function runGlmNarutoMission(input) {
         });
         passedEnvelopes = envelopes.filter((e) => e.status === 'gate_passed');
     }
-    const warnings = input.skipVerifier && passedEnvelopes.length > 0 ? ['verifier_skipped_by_flag'] : [];
+    envelopes = envelopes.map((env) => enrichGlmNarutoCandidateRequirementCoverage({ envelope: env, ledger: requirementLedger }));
+    passedEnvelopes = envelopes.filter((e) => e.status === 'gate_passed');
+    const verifierWarnings = input.skipVerifier && passedEnvelopes.length > 0 ? ['verifier_skipped_by_flag'] : [];
     // Build conflict graph and merge plan
+    const conflictMergeStartedMs = Date.now();
     const nodes = passedEnvelopes.map((env) => ({
         patch_id: env.worker_id,
         shard_id: env.shard_id,
@@ -227,32 +257,59 @@ export async function runGlmNarutoMission(input) {
         useJudge: input.useJudge || false,
         xhighFinalizer: input.xhighFinalizer || false
     });
+    const conflictMergeMs = Date.now() - conflictMergeStartedMs;
+    const candidateRequirementCoverage = envelopes.map((env) => inferCandidateRequirementCoverage({ envelope: env, ledger: requirementLedger }));
+    const preliminarySelectedPatchIds = mergePlan.selected_patches;
+    const requirementCoverageSummary = buildGlmNarutoRequirementCoverageSummary({
+        missionId,
+        ledger: requirementLedger,
+        envelopes,
+        selectedPatchIds: preliminarySelectedPatchIds
+    });
+    const selectedPatchIds = requirementCoverageSummary.passed ? preliminarySelectedPatchIds : [];
     // Apply winning merge plan
     let appliedPatches = 0;
     let applyResult = null;
     let applyTransaction = null;
     const artifactDir = path.join(cwd, '.sneakoscope', 'glm-naruto', missionId);
-    if (!input.noApply && mergePlan.selected_patches.length > 0) {
+    let finalApplyMs = null;
+    if (!input.noApply && selectedPatchIds.length > 0) {
+        const finalApplyStartedMs = Date.now();
         const transactionResult = await runGlmNarutoApplyTransaction({
             cwd,
             missionId,
             envelopes,
-            selectedPatchIds: mergePlan.selected_patches,
+            selectedPatchIds,
             artifactDir,
             ...(input.allowDirtyApply !== undefined ? { allowDirtyApply: input.allowDirtyApply } : {}),
             ...(input.noRollback !== undefined ? { noRollback: input.noRollback } : {}),
             ...(input.strictChecks !== undefined ? { strictChecks: input.strictChecks } : {})
         });
+        finalApplyMs = Date.now() - finalApplyStartedMs;
         applyTransaction = transactionResult.transaction;
         appliedPatches = transactionResult.ok ? transactionResult.applied.length : 0;
         applyResult = { ok: transactionResult.ok, applied: transactionResult.applied, ...(transactionResult.transaction.blockers[0] ? { blocker: transactionResult.transaction.blockers[0] } : {}) };
     }
-    const terminalState = appliedPatches > 0 ? 'completed' : passedEnvelopes.length > 0 ? 'partial_candidates' : 'blocked';
+    const coverageBlocked = !requirementCoverageSummary.passed;
+    const terminalState = appliedPatches > 0
+        ? 'completed'
+        : passedEnvelopes.length > 0 ? 'partial_candidates' : 'blocked';
     const terminationReason = appliedPatches > 0
         ? 'completed_merge_applied'
         : applyResult && !applyResult.ok
             ? 'apply_transaction_failed'
-            : passedEnvelopes.length > 0 ? 'partial_no_apply' : 'no_gate_passed_candidates';
+            : coverageBlocked
+                ? 'required_requirement_coverage_missing'
+                : passedEnvelopes.length > 0 ? 'partial_no_apply' : 'no_gate_passed_candidates';
+    const parallelismSummary = buildGlmNarutoParallelismSummary({
+        metrics: stageMetrics,
+        totalWallClockMs: Date.now() - startedMs
+    });
+    const warnings = [
+        ...verifierWarnings,
+        ...parallelismSummary.blockers,
+        ...(coverageBlocked ? ['required_requirement_coverage_missing'] : [])
+    ];
     const summary = buildMissionSummary({
         missionId,
         startedMs,
@@ -282,7 +339,9 @@ export async function runGlmNarutoMission(input) {
         failed_shards: summary.failed_shards,
         repair_waves: summary.repair_waves,
         budget_used_ms: summary.budget_used_ms,
-        blockers: terminalState === 'blocked' ? ['no_gate_passed_candidates'] : (applyResult && !applyResult.ok ? [applyResult.blocker || 'apply_transaction_failed'] : []),
+        blockers: coverageBlocked
+            ? requirementCoverageSummary.uncovered_required_requirements.map((id) => `required_requirement_uncovered:${id}`)
+            : terminalState === 'blocked' ? ['no_gate_passed_candidates'] : (applyResult && !applyResult.ok ? [applyResult.blocker || 'apply_transaction_failed'] : []),
         warnings
     };
     const writtenArtifactDir = await writeMissionArtifacts({
@@ -304,6 +363,15 @@ export async function runGlmNarutoMission(input) {
         missionResult: result,
         envelopes
     });
+    await writeJsonAtomic(path.join(writtenArtifactDir, 'requirement-ledger.json'), requirementLedger).catch(() => undefined);
+    await writeJsonAtomic(path.join(writtenArtifactDir, 'candidate-requirement-coverage.json'), candidateRequirementCoverage).catch(() => undefined);
+    await writeJsonAtomic(path.join(writtenArtifactDir, 'requirement-coverage-summary.json'), requirementCoverageSummary).catch(() => undefined);
+    await writeGlmNarutoParallelismArtifacts({
+        root: cwd,
+        missionId,
+        summary: parallelismSummary,
+        events: stageEvents
+    }).catch(() => undefined);
     const secretAudit = await auditGlmNarutoArtifactsForSecrets(path.join(cwd, '.sneakoscope', 'glm-naruto', missionId)).catch((err) => ({
         schema: 'sks.glm-naruto-secret-audit.v1',
         ok: false,
@@ -313,6 +381,7 @@ export async function runGlmNarutoMission(input) {
     }));
     await writeJsonAtomic(path.join(writtenArtifactDir, 'secret-audit.json'), secretAudit).catch(() => undefined);
     const predictedStopGatePath = path.join(cwd, '.sneakoscope', 'missions', missionId, 'stop-gate.json');
+    const finalSealStartedMs = Date.now();
     const finalSeal = await writeGlmNarutoFinalSeal({
         artifactDir: writtenArtifactDir,
         missionId,
@@ -321,7 +390,8 @@ export async function runGlmNarutoMission(input) {
         traces: traceState.workerTraces,
         isolationPolicy,
         scheduler: schedulerSummary,
-        selectedPatchIds: mergePlan.selected_patches,
+        selectedPatchIds,
+        requirementCoverage: requirementCoverageSummary,
         applyTransaction,
         secretAudit,
         stopGatePath: predictedStopGatePath,
@@ -332,6 +402,17 @@ export async function runGlmNarutoMission(input) {
         passed: false,
         error: err instanceof Error ? err.message : String(err)
     }));
+    const finalSealMs = Date.now() - finalSealStartedMs;
+    const criticalPath = buildGlmNarutoCriticalPathMetrics({
+        totalWallClockMs: Date.now() - startedMs,
+        stages: parallelismSummary.stages,
+        decompositionMs,
+        conflictMergeMs,
+        finalApplyMs,
+        finalSealMs,
+        parallelismWarnings: parallelismSummary.blockers
+    });
+    await writeGlmNarutoCriticalPathArtifacts({ root: cwd, missionId, metrics: criticalPath }).catch(() => undefined);
     // 4.0.9: Write canonical stop-gate artifacts for hook resolution.
     await writeFinalStopGate({
         root: cwd,
@@ -350,6 +431,11 @@ export async function runGlmNarutoMission(input) {
             model_guard_enforced: true,
             final_seal_passed: finalSeal.passed,
             final_seal_path: finalSeal.path,
+            required_coverage_passed: requirementCoverageSummary.passed,
+            uncovered_required_count: requirementCoverageSummary.uncovered_required_requirements.length,
+            coverage_ledger_path: path.join(writtenArtifactDir, 'requirement-coverage-summary.json'),
+            parallelism_summary_path: path.join(writtenArtifactDir, 'parallelism-summary.json'),
+            critical_path_path: path.join(writtenArtifactDir, 'critical-path.json'),
             proof_required: false,
             proof_passed: true,
             reflection_required: false,

package/dist/core/providers/glm/naruto/glm-naruto-parallelism-summary.js

@@ -0,0 +1,55 @@
+import path from 'node:path';
+import { writeJsonAtomic, writeTextAtomic } from '../../../fsx.js';
+export function metricFromStageResult(result) {
+    return {
+        stage: result.stage,
+        job_count: result.results.length,
+        max_observed_active: result.max_observed_active,
+        wall_clock_ms: result.wall_clock_ms,
+        sum_job_duration_ms: result.sum_job_duration_ms,
+        overlap_ratio: result.overlap_ratio
+    };
+}
+export function createStageParallelismMetric(input) {
+    return {
+        ...input,
+        wall_clock_ms: Math.max(0, input.wall_clock_ms),
+        sum_job_duration_ms: Math.max(0, input.sum_job_duration_ms),
+        overlap_ratio: input.wall_clock_ms > 0 ? input.sum_job_duration_ms / input.wall_clock_ms : input.overlap_ratio
+    };
+}
+export function buildGlmNarutoParallelismSummary(input) {
+    const grouped = new Map();
+    for (const metric of input.metrics) {
+        const current = grouped.get(metric.stage);
+        if (!current) {
+            grouped.set(metric.stage, createStageParallelismMetric(metric));
+            continue;
+        }
+        grouped.set(metric.stage, createStageParallelismMetric({
+            stage: metric.stage,
+            job_count: current.job_count + metric.job_count,
+            max_observed_active: Math.max(current.max_observed_active, metric.max_observed_active),
+            wall_clock_ms: current.wall_clock_ms + metric.wall_clock_ms,
+            sum_job_duration_ms: current.sum_job_duration_ms + metric.sum_job_duration_ms,
+            overlap_ratio: 1
+        }));
+    }
+    const stages = [...grouped.values()];
+    const blockers = stages
+        .filter((stage) => stage.job_count > 1 && stage.overlap_ratio <= 1.1)
+        .map((stage) => `glm_parallelism_not_effective:${stage.stage}`);
+    return {
+        schema: 'sks.glm-naruto-parallelism-summary.v1',
+        stages,
+        total_wall_clock_ms: Math.max(0, input.totalWallClockMs),
+        parallelism_effective: blockers.length === 0,
+        blockers
+    };
+}
+export async function writeGlmNarutoParallelismArtifacts(input) {
+    const dir = path.join(input.root, '.sneakoscope', 'glm-naruto', input.missionId);
+    await writeTextAtomic(path.join(dir, 'stage-timeline.jsonl'), input.events.map((event) => JSON.stringify(event)).join('\n') + (input.events.length ? '\n' : ''));
+    await writeJsonAtomic(path.join(dir, 'parallelism-summary.json'), input.summary);
+}
+//# sourceMappingURL=glm-naruto-parallelism-summary.js.map

package/dist/core/providers/glm/naruto/glm-naruto-requirement-coverage.js

@@ -0,0 +1,92 @@
+export function enrichGlmNarutoCandidateRequirementCoverage(input) {
+    const coverage = inferCandidateRequirementCoverage(input);
+    return {
+        ...input.envelope,
+        requirements_satisfied: coverage.requirements_satisfied,
+        requirements_risk: coverage.requirements_risk,
+        assumptions: coverage.assumptions
+    };
+}
+export function inferCandidateRequirementCoverage(input) {
+    const satisfied = [];
+    const risk = [];
+    const missing = [];
+    const assumptions = [];
+    const touched = new Set(input.envelope.target_paths);
+    const patch = input.envelope.patch.toLowerCase();
+    for (const requirement of input.ledger.requirements) {
+        const relatedPaths = extractPaths(requirement.text);
+        const pathCovered = relatedPaths.some((file) => touched.has(file) || patch.includes(file.toLowerCase()));
+        const lower = requirement.text.toLowerCase();
+        const preservationClause = /\b(preserve|do not|don't|without|never|no fallback|no fake|보존|금지|없이)\b/.test(lower);
+        const onlyClause = /\bonly\b|만\b/.test(lower);
+        if (relatedPaths.length > 0 && pathCovered && (!onlyClause || input.envelope.target_paths.every((file) => relatedPaths.includes(file)))) {
+            satisfied.push(requirement.id);
+            continue;
+        }
+        if (onlyClause && relatedPaths.length > 0 && input.envelope.target_paths.some((file) => !relatedPaths.includes(file))) {
+            risk.push(requirement.id);
+            missing.push(requirement.id);
+            continue;
+        }
+        if (preservationClause) {
+            risk.push(requirement.id);
+            missing.push(requirement.id);
+            assumptions.push(`manual_preservation_evidence_required:${requirement.id}`);
+            continue;
+        }
+        if (input.envelope.patch.trim()) {
+            satisfied.push(requirement.id);
+        }
+        else {
+            missing.push(requirement.id);
+        }
+    }
+    return {
+        schema: 'sks.glm-naruto-candidate-requirement-coverage.v1',
+        mission_id: input.envelope.mission_id,
+        worker_id: input.envelope.worker_id,
+        patch_id: input.envelope.patch_sha256,
+        requirements_satisfied: [...new Set(satisfied)],
+        requirements_risk: [...new Set(risk)],
+        requirements_missing: [...new Set(missing)],
+        assumptions: [...new Set(assumptions)]
+    };
+}
+export function buildGlmNarutoRequirementCoverageSummary(input) {
+    const selected = input.selectedPatchIds.length
+        ? input.envelopes.filter((env) => input.selectedPatchIds.includes(env.worker_id))
+        : input.envelopes;
+    const rows = input.ledger.requirements.map((requirement) => {
+        const satisfiedBy = selected
+            .filter((env) => env.requirements_satisfied?.includes(requirement.id))
+            .map((env) => env.worker_id);
+        const riskBy = selected
+            .filter((env) => env.requirements_risk?.includes(requirement.id))
+            .map((env) => env.worker_id);
+        const covered = satisfiedBy.length > 0 && riskBy.length === 0;
+        return {
+            requirement_id: requirement.id,
+            required: requirement.required,
+            covered,
+            satisfied_by: satisfiedBy,
+            risk_by: riskBy
+        };
+    });
+    const uncovered = rows
+        .filter((row) => row.required && !row.covered)
+        .map((row) => row.requirement_id);
+    return {
+        schema: 'sks.glm-naruto-requirement-coverage-summary.v1',
+        mission_id: input.missionId,
+        required_total: input.ledger.requirements.filter((req) => req.required).length,
+        required_covered: rows.filter((row) => row.required && row.covered).length,
+        uncovered_required_requirements: uncovered,
+        passed: uncovered.length === 0,
+        requirements: rows
+    };
+}
+function extractPaths(text) {
+    return [...new Set(text.match(/[A-Za-z0-9_.-]+\/[A-Za-z0-9_./-]+\.[A-Za-z0-9]+/g) ?? [])];
+}
+//# sourceMappingURL=glm-naruto-requirement-coverage.js.map

package/dist/core/providers/glm/naruto/glm-naruto-requirement-ledger.js

@@ -0,0 +1,42 @@
+export function buildGlmNarutoRequirementLedger(input) {
+    const requirements = [];
+    const seen = new Set();
+    const add = (text, source, required = true) => {
+        const clean = text.replace(/\s+/g, ' ').trim();
+        if (!clean || seen.has(`${source}:${clean.toLowerCase()}`))
+            return;
+        seen.add(`${source}:${clean.toLowerCase()}`);
+        requirements.push({
+            id: `REQ-${String(requirements.length + 1).padStart(3, '0')}`,
+            text: clean,
+            source,
+            required
+        });
+    };
+    for (const clause of splitRequirementClauses(input.task)) {
+        const lower = clause.toLowerCase();
+        if (/\b(must|without|do not|don't|preserve|only|never|no fallback|no fake|금지|필수|보존|없이|만)\b/.test(lower)) {
+            add(clause, 'user_task', true);
+        }
+    }
+    for (const file of input.mentionedPaths ?? []) {
+        add(`Touch or preserve mentioned path: ${file}`, 'user_task', true);
+    }
+    if (input.gitStatus && input.gitStatus.trim()) {
+        add('Preserve pre-existing dirty worktree changes unless explicitly selected.', 'git_status', true);
+    }
+    if (requirements.length === 0)
+        add(input.task, 'user_task', true);
+    return {
+        schema: 'sks.glm-naruto-requirement-ledger.v1',
+        mission_id: input.missionId,
+        requirements
+    };
+}
+function splitRequirementClauses(task) {
+    return task
+        .split(/\r?\n|[.;]|(?:\s+-\s+)/g)
+        .map((part) => part.replace(/^[-*\d.)\s]+/, '').trim())
+        .filter(Boolean);
+}
+//# sourceMappingURL=glm-naruto-requirement-ledger.js.map