sneakoscope 4.0.13 → 4.0.14

package/README.md

@@ -35,9 +35,17 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-SKS **4.0.12** seals GLM Naruto's production runtime path: worktree workers apply extracted unified diffs only, patch workers launch through a bounded adaptive scheduler, live bench compares true direct GLM against Naruto worker counts, final apply runs dirty-tree and targeted-check guards, and stop-gates reference a final seal artifact.
+SKS **4.0.14** seals GLM Naruto real parallelism while preserving the existing GPT/Codex/MAD `sks --mad` route. GLM mode stays locked to OpenRouter `z-ai/glm-5.2`; non-GLM MAD does not require OpenRouter, does not select GLM, and does not enter the GLM Naruto scheduler.
 
-What changed in 4.0.12:
+What changed in 4.0.14:
+
+- **Real stage parallelism evidence.** GLM Naruto records bounded parallel stage timelines, overlap ratios, parallelism summaries, critical-path metrics, and speed diagnosis artifacts.
+- **Parallel gate/verifier/worktree stages.** Candidate gate, worktree materialization, and verifier checks no longer have to run candidate-by-candidate when multiple candidates are available.
+- **Requirement coverage seal.** GLM Naruto writes a requirement ledger and candidate coverage artifacts, and the final seal blocks when required requirements remain uncovered.
+- **MAD route isolation.** `sks --mad` without `--glm` remains the GPT/Codex/MAD route and does not resolve OpenRouter or run GLM-specific benchmark/Naruto code.
+- **Benchmark proof honesty.** GLM benchmark proof now reports request-summary availability separately from case-level model lock checks and fixes the no-mutation proof boolean.
+
+What changed in 4.0.13:
 
 - **Extracted worktree patches.** `--worktree` parses `<sks_patch_candidate>` and records candidate/extracted patch hashes before any worker worktree apply.
 - **Adaptive scheduler.** Patch workers use a finite launch queue with provider-health backpressure and retry-once handling for retryable 429/5xx/idle-timeout failures.

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "4.0.12"
+version = "4.0.14"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "4.0.12"
+version = "4.0.14"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 4.0.12"),
+        Some("--version") => println!("sks-rs 4.0.14"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '4.0.13';
+const FAST_PACKAGE_VERSION = '4.0.14';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/cli/global-mode-router.js

@@ -6,8 +6,9 @@ export function detectGlobalMode(args = []) {
     const hasGlm = args.includes('--glm');
     if (hasMad && hasGlm)
         return { kind: 'mad-glm', args: stripGlobalModeFlags(args) };
-    if (hasGlm && !hasMad)
+    if (hasGlm && !hasMad && String(args[0]).startsWith('-')) {
         return { kind: 'glm-without-mad', args: stripGlobalModeFlags(args) };
+    }
     return null;
 }
 export function stripGlobalModeFlags(args) {

package/dist/core/commands/mad-sks-command.js

@@ -26,12 +26,15 @@ import { resolveCodexNativeInvocationPlan } from '../codex-native/codex-native-i
 import { repairZellijForSks } from '../zellij/zellij-self-heal.js';
 import { buildMadGlmLaunchArtifact, buildMadGlmLaunchProfileNoWrite, resolveMadGlmLaunchKey, writeMadGlmCodexWrapper } from '../providers/glm/glm-mad-launch.js';
 import { GLM_MAD_MODE } from '../providers/glm/glm-52-settings.js';
+import { assertNonGlmMadRoute } from '../routes/model-mode-router.js';
 export async function madHighCommand(args = [], deps = {}) {
     const subcommand = firstSubcommand(args);
     if (subcommand)
         return madSksSubcommand(subcommand, args.filter((arg) => String(arg) !== subcommand));
     const rawArgs = (args || []).map((arg) => String(arg));
     const glmMadLaunch = isMadGlmLaunch(rawArgs, deps);
+    if (!glmMadLaunch)
+        assertNonGlmMadRoute(rawArgs.includes('--mad') ? rawArgs : ['--mad', ...rawArgs]);
     const glmOnlyFlagBlockers = findGlmOnlyMadFlagBlockers(rawArgs, glmMadLaunch);
     if (glmOnlyFlagBlockers.length) {
         const result = {

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '4.0.13';
+export const PACKAGE_VERSION = '4.0.14';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

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.14',
         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.14',
         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.14',
         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.14';
 //# 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