sneakoscope 4.0.11 → 4.0.12

package/README.md

@@ -35,15 +35,15 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-SKS **4.0.11** makes GLM Naruto operationally measurable: `--worktree` is honest, live bench records real worker/verifier/cache metrics, candidates are scored before merge planning, final apply writes rollback-aware transaction evidence, and early terminal paths write canonical stop-gates. Ordinary direct GLM remains available for single-path edits, while GLM Naruto is the measured parallel runtime.
+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.
 
-What changed in 4.0.11:
+What changed in 4.0.12:
 
-- **Honest worktree isolation.** `sks --mad --glm --naruto --worktree "<task>"` uses per-worker git worktrees when available or blocks unless `--allow-patch-envelope-fallback` is explicit.
-- **Measured live bench.** `--bench --live --no-apply` still runs verifier/scoring and reports TTFT, total latency, verifier pass rate, cache tokens, reasoning tokens, and worker completion/failure counts.
-- **Scoreboard-driven merge planning.** `candidate-scoreboard.json` captures gate, verifier, risk, confidence, path, conflict, latency, cache, diversity, and secret-safety components.
-- **Rollback-aware apply.** Final mutation is single-threaded and records `apply-transaction.json`, selected combined patch, diff hashes, and rollback evidence.
-- **Terminal evidence and artifact safety.** Missing-key, invalid-graph, budget, and no-candidate terminal paths write canonical stop-gates, and GLM Naruto artifacts use key-aware secret audit/redaction.
+- **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.
+- **True direct-vs-Naruto bench.** `--bench --live --no-apply` compares direct GLM, Naruto 1, 4, 8, and 12 worker cases without fake zero metrics.
+- **Transaction guards.** Final apply blocks dirty touched paths unless `--allow-dirty-apply` is explicit, runs targeted checks, and rolls back on validation failure by default.
+- **Seal artifacts.** GLM Naruto writes `final-seal.json`, stop-gate final-seal evidence, `merge-rationale.md`, and `bench-report.md` for auditability.
 
 What changed in 4.0.8:
 

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "4.0.11"
+version = "4.0.12"
 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.9"),
+        Some("--version") => println!("sks-rs 4.0.12"),
         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.11';
+const FAST_PACKAGE_VERSION = '4.0.12';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

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.11';
+export const PACKAGE_VERSION = '4.0.12';
 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/naruto/glm-naruto-apply-transaction.js

@@ -3,22 +3,28 @@ import path from 'node:path';
 import { sha256, writeJsonAtomic, writeTextAtomic } from '../../../fsx.js';
 import { parseUnifiedDiffPatch } from '../glm-patch-parser.js';
 import { combineGlmNarutoPatches } from './glm-naruto-combined-patch.js';
+import { runGlmNarutoTargetedChecks } from './glm-naruto-targeted-checks.js';
 export async function runGlmNarutoApplyTransaction(input) {
     const preStatus = await gitText(input.cwd, ['status', '--short']);
     const preDiff = await gitText(input.cwd, ['diff', '--binary']);
     const patch = combineGlmNarutoPatches(input.envelopes, input.selectedPatchIds);
     const parsed = parseUnifiedDiffPatch(patch);
+    const dirtyTouchedPaths = await dirtyPaths(input.cwd, parsed.touchedPaths);
     const patchPath = path.join(input.artifactDir, 'selected-combined.patch');
     await writeTextAtomic(patchPath, patch);
     const blockers = [];
     let applyCheckPassed = false;
     let applyPassed = false;
+    let targetedChecksPassed = null;
     let rollbackAttempted = false;
     let rollbackPassed = null;
     let finalStatus = 'blocked';
     if (!patch.trim()) {
         blockers.push('combined_patch_empty');
     }
+    else if (dirtyTouchedPaths.length > 0 && !input.allowDirtyApply) {
+        blockers.push(`dirty_touched_paths_before_apply:${dirtyTouchedPaths.join(',')}`);
+    }
     else {
         const checked = await gitApply(input.cwd, patch, ['apply', '--check', '--whitespace=nowarn', '-']);
         applyCheckPassed = checked.code === 0;
@@ -28,16 +34,41 @@ export async function runGlmNarutoApplyTransaction(input) {
             const applied = await gitApply(input.cwd, patch, ['apply', '--whitespace=nowarn', '-']);
             applyPassed = applied.code === 0;
             if (applyPassed) {
-                finalStatus = 'applied';
+                const targeted = await runGlmNarutoTargetedChecks({
+                    cwd: input.cwd,
+                    touchedPaths: parsed.touchedPaths,
+                    artifactDir: input.artifactDir,
+                    ...(input.strictChecks !== undefined ? { strictChecks: input.strictChecks } : {})
+                });
+                targetedChecksPassed = targeted.ok;
+                if (targeted.ok) {
+                    finalStatus = 'applied';
+                }
+                else {
+                    blockers.push(...targeted.blockers);
+                    if (!input.noRollback) {
+                        rollbackAttempted = true;
+                        const rollback = await gitApply(input.cwd, patch, ['apply', '-R', '--whitespace=nowarn', '-']);
+                        rollbackPassed = rollback.code === 0;
+                        finalStatus = rollbackPassed ? 'rolled_back' : 'blocked';
+                        if (!rollbackPassed)
+                            blockers.push(rollback.stderr || rollback.stdout || 'rollback_reverse_patch_failed');
+                    }
+                    else {
+                        finalStatus = 'blocked';
+                    }
+                }
             }
             else {
                 blockers.push(applied.stderr || applied.stdout || 'git_apply_failed');
-                rollbackAttempted = true;
-                const rollback = await gitApply(input.cwd, patch, ['apply', '-R', '--whitespace=nowarn', '-']);
-                rollbackPassed = rollback.code === 0;
-                finalStatus = rollbackPassed ? 'rolled_back' : 'blocked';
-                if (!rollbackPassed)
-                    blockers.push(rollback.stderr || rollback.stdout || 'rollback_reverse_patch_failed');
+                if (!input.noRollback) {
+                    rollbackAttempted = true;
+                    const rollback = await gitApply(input.cwd, patch, ['apply', '-R', '--whitespace=nowarn', '-']);
+                    rollbackPassed = rollback.code === 0;
+                    finalStatus = rollbackPassed ? 'rolled_back' : 'blocked';
+                    if (!rollbackPassed)
+                        blockers.push(rollback.stderr || rollback.stdout || 'rollback_reverse_patch_failed');
+                }
             }
         }
     }
@@ -47,12 +78,15 @@ export async function runGlmNarutoApplyTransaction(input) {
         mission_id: input.missionId,
         selected_patch_ids: input.selectedPatchIds,
         touched_paths: parsed.touchedPaths,
+        dirty_touched_paths_before_apply: dirtyTouchedPaths,
+        dirty_policy: input.allowDirtyApply ? 'allow' : 'block',
         pre_status: preStatus,
         pre_diff_sha256: sha256(preDiff),
+        post_diff_sha256: sha256(postDiff),
         combined_patch_sha256: sha256(patch),
         apply_check_passed: applyCheckPassed,
         apply_passed: applyPassed,
-        targeted_checks_passed: null,
+        targeted_checks_passed: targetedChecksPassed,
         rollback_attempted: rollbackAttempted,
         rollback_passed: rollbackPassed,
         final_status: finalStatus,
@@ -76,6 +110,18 @@ function gitText(cwd, args) {
         child.on('close', () => resolve(stdout));
     });
 }
+async function dirtyPaths(cwd, paths) {
+    if (paths.length === 0)
+        return [];
+    const status = await gitText(cwd, ['status', '--short', '--', ...paths]);
+    return status.split(/\r?\n/)
+        .map((line) => line.trimEnd())
+        .filter(Boolean)
+        .map((line) => {
+        const raw = line.slice(3).trim();
+        return raw.includes(' -> ') ? raw.split(' -> ').pop().trim() : raw;
+    });
+}
 function gitApply(cwd, patch, args) {
     return new Promise((resolve) => {
         const child = spawn('git', [...args], { cwd, stdio: ['pipe', 'pipe', 'pipe'] });

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

@@ -1,22 +1,25 @@
-import { nowIso } from '../../../fsx.js';
+import { nowIso, writeTextAtomic } from '../../../fsx.js';
 import path from 'node:path';
 import fsp from 'node:fs/promises';
 import os from 'node:os';
 import { GLM_52_OPENROUTER_MODEL } from '../glm-52-settings.js';
+import { runGlmDirectSpeedRun } from '../glm-direct-run.js';
 import { resolveOpenRouterApiKey } from '../../openrouter/openrouter-secret-store.js';
 import { runGlmNarutoMission } from './glm-naruto-orchestrator.js';
 import { summarizeGlmNarutoWorkerMetrics } from './glm-naruto-metrics.js';
-export async function runGlmNarutoBench(root, args = []) {
+export async function runGlmNarutoBench(root, args = [], deps = {}) {
     const live = args.includes('--live');
     const execute = args.includes('--execute');
     const started = Date.now();
+    const runDirect = deps.runDirect ?? runGlmDirectSpeedRun;
+    const runNaruto = deps.runNaruto ?? runGlmNarutoMission;
     if (execute && !live) {
         return blocked(root, ['execute_requires_live_flag']);
     }
     if (!live) {
         return {
             schema: 'sks.glm-naruto-bench.v1',
-            version: '4.0.11',
+            version: '4.0.12',
             generated_at: nowIso(),
             status: 'dry_run',
             model: GLM_52_OPENROUTER_MODEL,
@@ -39,9 +42,17 @@ export async function runGlmNarutoBench(root, args = []) {
     await fsp.mkdir(path.join(fixture, 'src'), { recursive: true });
     await fsp.writeFile(path.join(fixture, 'src', 'bench-target.ts'), 'export const value = 1;\n', 'utf8');
     const cases = [];
+    const directStarted = Date.now();
+    const direct = await runDirect({
+        cwd: fixture,
+        task: 'Change src/bench-target.ts so value is 2. Return the smallest patch only.',
+        args: ['--bench', '--live', '--dry-run'],
+        dryRun: true
+    });
+    cases.push(directBenchCase(direct, Date.now() - directStarted));
     for (const workers of [1, 4, 8, 12]) {
         const caseStarted = Date.now();
-        const result = await runGlmNarutoMission({
+        const result = await runNaruto({
             cwd: fixture,
             task: 'Change src/bench-target.ts so value is 2. Return the smallest patch only.',
             args: ['--bench', '--live', '--no-apply'],
@@ -52,7 +63,8 @@ export async function runGlmNarutoBench(root, args = []) {
         const traces = await readWorkerTraces(result.artifact_dir);
         const metrics = summarizeGlmNarutoWorkerMetrics(traces);
         cases.push({
-            name: workers === 1 ? 'direct single GLM' : `GLM Naruto ${workers} workers`,
+            name: `GLM Naruto ${workers} worker${workers === 1 ? '' : 's'}`,
+            kind: 'glm-naruto',
             workers,
             wall_clock_ms: Date.now() - caseStarted,
             p50_ttft_ms: metrics.p50_ttft_ms,
@@ -60,19 +72,21 @@ export async function runGlmNarutoBench(root, args = []) {
             p50_total_ms: metrics.p50_total_ms,
             p90_total_ms: metrics.p90_total_ms,
             candidate_count: result.patch_candidates,
-            gate_pass_rate: result.patch_candidates ? result.gate_passed_candidates / result.patch_candidates : 0,
+            gate_pass_rate: result.patch_candidates ? result.gate_passed_candidates / result.patch_candidates : null,
             verifier_pass_rate: metrics.verifier_pass_rate,
             merge_success: result.mergeable_candidates > 0,
             cached_tokens_sum: metrics.cached_tokens_sum,
             cache_write_tokens_sum: metrics.cache_write_tokens_sum,
             reasoning_tokens_sum: metrics.reasoning_tokens_sum,
+            metric_status: metrics.p50_total_ms === null && metrics.p50_ttft_ms === null ? 'unavailable' : 'measured',
             workers_completed: metrics.workers_completed,
             workers_failed: metrics.workers_failed
         });
     }
+    await writeBenchReport(root, cases).catch(() => undefined);
     return {
         schema: 'sks.glm-naruto-bench.v1',
-        version: '4.0.11',
+        version: '4.0.12',
         generated_at: nowIso(),
         status: 'live',
         model: GLM_52_OPENROUTER_MODEL,
@@ -82,17 +96,48 @@ export async function runGlmNarutoBench(root, args = []) {
             simulated_workers: Math.max(...cases.map((row) => row.workers)),
             simulated_waves: cases.length,
             simulated_patch_candidates: cases.reduce((sum, row) => sum + row.candidate_count, 0),
-            simulated_gate_passed: cases.reduce((sum, row) => sum + Math.round(row.candidate_count * row.gate_pass_rate), 0),
+            simulated_gate_passed: cases.reduce((sum, row) => sum + Math.round(row.candidate_count * (row.gate_pass_rate ?? 0)), 0),
             simulated_mergeable: cases.filter((row) => row.merge_success).length,
             wall_clock_ms: Date.now() - started
         },
         warnings: ['live_bench_no_apply_temp_repo']
     };
 }
+async function writeBenchReport(root, cases) {
+    const rows = cases.map((row) => [
+        row.name,
+        row.kind,
+        String(row.workers),
+        String(row.wall_clock_ms),
+        String(row.p50_ttft_ms ?? 'unavailable'),
+        String(row.p90_ttft_ms ?? 'unavailable'),
+        String(row.p50_total_ms ?? 'unavailable'),
+        String(row.p90_total_ms ?? 'unavailable'),
+        String(row.gate_pass_rate ?? 'n/a'),
+        String(row.verifier_pass_rate ?? 'n/a'),
+        String(row.metric_status)
+    ]);
+    const fastest = [...cases].sort((a, b) => a.wall_clock_ms - b.wall_clock_ms)[0] ?? null;
+    const md = [
+        '# GLM Naruto Bench Report',
+        '',
+        `Generated: ${nowIso()}`,
+        `Model: ${GLM_52_OPENROUTER_MODEL}`,
+        '',
+        '| Case | Kind | Workers | Wall ms | TTFT p50 | TTFT p90 | Total p50 | Total p90 | Gate pass | Verifier pass | Metric status |',
+        '| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |',
+        ...rows.map((row) => `| ${row.join(' | ')} |`),
+        '',
+        `Fastest wall-clock case: ${fastest ? fastest.name : 'unavailable'}`,
+        'Missing usage metrics are reported as `unavailable` or `n/a`, never as fake zero.',
+        ''
+    ].join('\n');
+    await writeTextAtomic(path.join(root, '.sneakoscope', 'glm-naruto', 'bench-report.md'), md);
+}
 function blocked(root, warnings) {
     return {
         schema: 'sks.glm-naruto-bench.v1',
-        version: '4.0.11',
+        version: '4.0.12',
         generated_at: nowIso(),
         status: 'blocked',
         model: GLM_52_OPENROUTER_MODEL,
@@ -108,6 +153,26 @@ function blocked(root, warnings) {
         warnings
     };
 }
+function directBenchCase(result, wallClockMs) {
+    return {
+        name: 'direct GLM speed path',
+        kind: 'direct-glm',
+        workers: 1,
+        wall_clock_ms: wallClockMs,
+        p50_ttft_ms: null,
+        p90_ttft_ms: null,
+        p50_total_ms: null,
+        p90_total_ms: null,
+        candidate_count: result.ok ? 1 : 0,
+        gate_pass_rate: result.ok ? 1 : null,
+        verifier_pass_rate: null,
+        merge_success: result.ok,
+        cached_tokens_sum: null,
+        cache_write_tokens_sum: null,
+        reasoning_tokens_sum: null,
+        metric_status: 'unavailable'
+    };
+}
 async function readWorkerTraces(artifactDir) {
     if (!artifactDir)
         return [];

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

@@ -46,6 +46,9 @@ export async function glmNarutoCommand(args = []) {
     const allowPatchEnvelopeFallback = flag(args, '--allow-patch-envelope-fallback');
     const noApply = flag(args, '--no-apply');
     const skipVerifier = flag(args, '--skip-verifier');
+    const allowDirtyApply = flag(args, '--allow-dirty-apply');
+    const noRollback = flag(args, '--no-rollback');
+    const strictChecks = flag(args, '--strict-checks');
     const mergeStrategy = readOption(args, '--merge-strategy', 'deterministic');
     const result = await runGlmNarutoMission({
         cwd: process.cwd(),
@@ -62,6 +65,9 @@ export async function glmNarutoCommand(args = []) {
         cleanupWorktrees,
         noApply: noApply || flag(args, '--dry-run'),
         skipVerifier,
+        allowDirtyApply,
+        noRollback,
+        strictChecks,
         mergeStrategy
     });
     if (flag(args, '--json')) {

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

@@ -0,0 +1,75 @@
+import path from 'node:path';
+import { writeJsonAtomic } from '../../../fsx.js';
+import { GLM_52_OPENROUTER_MODEL } from '../glm-52-settings.js';
+export async function writeGlmNarutoFinalSeal(input) {
+    const mismatches = [
+        ...input.envelopes.filter((env) => env.model !== GLM_52_OPENROUTER_MODEL || env.gpt_fallback_allowed !== false).map((env) => `envelope:${env.worker_id}`),
+        ...input.traces.filter((trace) => trace.model !== GLM_52_OPENROUTER_MODEL).map((trace) => `trace:${trace.worker_id}`)
+    ];
+    const isolationViolations = input.isolationPolicy.selected === 'blocked' ? input.isolationPolicy.blockers : [];
+    const status = finalSealStatus({
+        result: input.result,
+        secretOk: input.secretAudit.ok,
+        mismatches,
+        isolationViolations,
+        queueDrained: input.scheduler.queue_drained
+    });
+    const seal = {
+        schema: 'sks.glm-naruto-final-seal.v1',
+        mission_id: input.missionId,
+        status,
+        model_lock: {
+            model: GLM_52_OPENROUTER_MODEL,
+            gpt_fallback_allowed: false,
+            requests_checked: input.envelopes.length + input.traces.length,
+            mismatches
+        },
+        isolation: {
+            selected: input.isolationPolicy.selected,
+            workers_write_main_workspace: false,
+            violations: isolationViolations
+        },
+        scheduler: {
+            bounded: true,
+            max_observed_active_workers: input.scheduler.max_observed_active_workers,
+            queue_drained: input.scheduler.queue_drained,
+            backpressure_events: input.scheduler.backpressure_events
+        },
+        candidates: {
+            total: input.envelopes.length,
+            gate_passed: input.envelopes.filter((env) => env.status === 'gate_passed').length,
+            verifier_passed: input.envelopes.filter((env) => env.verification_passed === true).length,
+            selected: input.selectedPatchIds
+        },
+        apply: {
+            attempted: input.applyTransaction !== null,
+            transaction_path: input.applyTransaction ? path.join(input.artifactDir, 'apply-transaction.json') : null,
+            final_status: input.applyTransaction?.final_status ?? null,
+            rollback_attempted: input.applyTransaction?.rollback_attempted ?? false,
+            rollback_passed: input.applyTransaction?.rollback_passed ?? null
+        },
+        secret_audit: {
+            ok: input.secretAudit.ok,
+            findings: input.secretAudit.findings ?? []
+        },
+        stop_gate: {
+            path: input.stopGatePath,
+            passed: input.stopGatePassed
+        }
+    };
+    const out = path.join(input.artifactDir, 'final-seal.json');
+    await writeJsonAtomic(out, seal);
+    return { seal, path: out, passed: seal.status === 'passed' };
+}
+function finalSealStatus(input) {
+    if (!input.secretOk || input.mismatches.length > 0 || input.isolationViolations.length > 0 || !input.queueDrained)
+        return 'blocked';
+    if (input.result.ok)
+        return 'passed';
+    if (input.result.status === 'partial_candidates')
+        return 'partial';
+    if (input.result.status === 'blocked')
+        return 'blocked';
+    return 'failed';
+}
+//# sourceMappingURL=glm-naruto-final-seal.js.map

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

@@ -20,6 +20,7 @@ import { getGitHead, getGitRoot } from './glm-naruto-worktree-manager.js';
 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 { GLM_NARUTO_LIMITS } from './glm-naruto-types.js';
 export async function runGlmNarutoMission(input) {
     const missionId = input.missionId || `glm-naruto-${nowIso().replace(/[:.]/g, '-')}`;
@@ -94,7 +95,8 @@ export async function runGlmNarutoMission(input) {
         strategies: strategyMap,
         isolationMode: isolationPolicy.selected,
         cleanupWorktrees: input.cleanupWorktrees ?? !input.keepWorktrees,
-        baseCommit
+        baseCommit,
+        health: healthTracker
     });
     for (const trace of poolResult.traces) {
         traceState = recordWorkerTrace(traceState, trace);
@@ -112,6 +114,7 @@ export async function runGlmNarutoMission(input) {
     let envelopes = poolResult.envelopes;
     let failedShardIds = poolResult.failedShardIds;
     let repairWaves = 0;
+    let schedulerSummary = poolResult.schedulerSummary;
     // Repair wave if needed
     if (failedShardIds.length > 0 && repairWaves < GLM_NARUTO_LIMITS.max_repair_waves) {
         const repairPlan = planRepairWave({
@@ -132,9 +135,15 @@ export async function runGlmNarutoMission(input) {
                 strategies: new Map(repairPlan.shardsToRepair.map((s) => [s.id, [s.strategy]])),
                 isolationMode: isolationPolicy.selected,
                 cleanupWorktrees: input.cleanupWorktrees ?? !input.keepWorktrees,
-                baseCommit
+                baseCommit,
+                health: healthTracker
             });
             envelopes = [...envelopes, ...repairPool.envelopes];
+            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,
+                queue_drained: schedulerSummary.queue_drained && repairPool.schedulerSummary.queue_drained
+            };
             for (const trace of repairPool.traces) {
                 traceState = recordWorkerTrace(traceState, trace);
             }
@@ -229,7 +238,10 @@ export async function runGlmNarutoMission(input) {
             missionId,
             envelopes,
             selectedPatchIds: mergePlan.selected_patches,
-            artifactDir
+            artifactDir,
+            ...(input.allowDirtyApply !== undefined ? { allowDirtyApply: input.allowDirtyApply } : {}),
+            ...(input.noRollback !== undefined ? { noRollback: input.noRollback } : {}),
+            ...(input.strictChecks !== undefined ? { strictChecks: input.strictChecks } : {})
         });
         applyTransaction = transactionResult.transaction;
         appliedPatches = transactionResult.ok ? transactionResult.applied.length : 0;
@@ -300,13 +312,33 @@ export async function runGlmNarutoMission(input) {
         findings: [`audit_failed:${err instanceof Error ? err.message : String(err)}`]
     }));
     await writeJsonAtomic(path.join(writtenArtifactDir, 'secret-audit.json'), secretAudit).catch(() => undefined);
+    const predictedStopGatePath = path.join(cwd, '.sneakoscope', 'missions', missionId, 'stop-gate.json');
+    const finalSeal = await writeGlmNarutoFinalSeal({
+        artifactDir: writtenArtifactDir,
+        missionId,
+        result,
+        envelopes,
+        traces: traceState.workerTraces,
+        isolationPolicy,
+        scheduler: schedulerSummary,
+        selectedPatchIds: mergePlan.selected_patches,
+        applyTransaction,
+        secretAudit,
+        stopGatePath: predictedStopGatePath,
+        stopGatePassed: result.ok && secretAudit.ok
+    }).catch((err) => ({
+        seal: null,
+        path: path.join(writtenArtifactDir, 'final-seal.json'),
+        passed: false,
+        error: err instanceof Error ? err.message : String(err)
+    }));
     // 4.0.9: Write canonical stop-gate artifacts for hook resolution.
     await writeFinalStopGate({
         root: cwd,
         missionId,
         route: 'GLM_NARUTO',
         routeCommand: '$Naruto',
-        status: result.ok && secretAudit.ok ? 'passed' : (terminalState === 'blocked' || !secretAudit.ok ? 'blocked' : 'failed'),
+        status: result.ok && secretAudit.ok && finalSeal.passed ? 'passed' : (terminalState === 'blocked' || !secretAudit.ok || !finalSeal.passed ? 'blocked' : 'failed'),
         terminal: terminalState === 'completed' || terminalState === 'blocked',
         terminalState,
         evidence: {
@@ -316,12 +348,16 @@ export async function runGlmNarutoMission(input) {
             per_worker_artifacts: true,
             verifier_wave_run: verifierWaveRun,
             model_guard_enforced: true,
+            final_seal_passed: finalSeal.passed,
+            final_seal_path: finalSeal.path,
             proof_required: false,
             proof_passed: true,
             reflection_required: false,
             reflection_passed: 'not_required',
         },
-        blockers: secretAudit.ok ? (result.blockers || []) : ['glm_naruto_secret_leak_detected'],
+        blockers: secretAudit.ok
+            ? (finalSeal.passed ? (result.blockers || []) : [...(result.blockers || []), 'glm_naruto_final_seal_not_passed'])
+            : ['glm_naruto_secret_leak_detected'],
         nativeGateFile: 'termination.json',
     }).catch(() => null);
     return { ...result, artifact_dir: writtenArtifactDir };

package/dist/core/providers/glm/naruto/glm-naruto-targeted-checks.js

@@ -0,0 +1,76 @@
+import { spawn } from 'node:child_process';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { exists, writeJsonAtomic } from '../../../fsx.js';
+export async function runGlmNarutoTargetedChecks(input) {
+    const checks = [];
+    const touchedPaths = [...new Set(input.touchedPaths)].sort();
+    const diffCheck = await runProcess(input.cwd, ['git', 'diff', '--check']);
+    checks.push({
+        id: 'git_diff_check',
+        ok: diffCheck.code === 0,
+        command: ['git', 'diff', '--check'],
+        ...(diffCheck.code === 0 ? {} : { message: diffCheck.stderr || diffCheck.stdout || 'git diff --check failed' })
+    });
+    for (const rel of touchedPaths.filter((file) => /\.(?:json)$/i.test(file))) {
+        const absolute = path.join(input.cwd, rel);
+        try {
+            JSON.parse(await fsp.readFile(absolute, 'utf8'));
+            checks.push({ id: 'json_parse', ok: true, path: rel });
+        }
+        catch (err) {
+            checks.push({ id: 'json_parse', ok: false, path: rel, message: err instanceof Error ? err.message : String(err) });
+        }
+    }
+    for (const rel of touchedPaths.filter((file) => /\.(?:js|mjs|cjs)$/i.test(file))) {
+        const nodeCheck = await runProcess(input.cwd, ['node', '--check', rel]);
+        checks.push({
+            id: 'node_check',
+            ok: nodeCheck.code === 0,
+            path: rel,
+            command: ['node', '--check', rel],
+            ...(nodeCheck.code === 0 ? {} : { message: nodeCheck.stderr || nodeCheck.stdout || 'node --check failed' })
+        });
+    }
+    const tsTouched = touchedPaths.filter((file) => /\.(?:ts|tsx)$/i.test(file));
+    const tscThreshold = input.tscFileThreshold ?? 3;
+    if (tsTouched.length > 0 && (input.strictChecks || tsTouched.length <= tscThreshold)) {
+        const tscBin = path.join(input.cwd, 'node_modules', '.bin', 'tsc');
+        const tsconfig = path.join(input.cwd, 'tsconfig.json');
+        if (await exists(tscBin) && await exists(tsconfig)) {
+            const tsc = await runProcess(input.cwd, [tscBin, '-p', 'tsconfig.json', '--noEmit']);
+            checks.push({
+                id: 'tsc_no_emit',
+                ok: tsc.code === 0,
+                command: [tscBin, '-p', 'tsconfig.json', '--noEmit'],
+                ...(tsc.code === 0 ? {} : { message: tsc.stderr || tsc.stdout || 'tsc --noEmit failed' })
+            });
+        }
+        else {
+            checks.push({ id: 'tsc_no_emit', ok: true, skipped: true, message: 'tsc_or_tsconfig_unavailable' });
+        }
+    }
+    const blockers = checks.filter((check) => !check.ok).map((check) => `${check.id}${check.path ? `:${check.path}` : ''}`);
+    const result = {
+        schema: 'sks.glm-naruto-targeted-checks.v1',
+        ok: blockers.length === 0,
+        touched_paths: touchedPaths,
+        checks,
+        blockers
+    };
+    if (input.artifactDir)
+        await writeJsonAtomic(path.join(input.artifactDir, 'targeted-checks.json'), result);
+    return result;
+}
+function runProcess(cwd, command) {
+    return new Promise((resolve) => {
+        const child = spawn(command[0], command.slice(1), { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => { stdout += String(chunk); });
+        child.stderr.on('data', (chunk) => { stderr += String(chunk); });
+        child.on('close', (code) => resolve({ code, stdout, stderr }));
+        child.on('error', (err) => resolve({ code: 1, stdout, stderr: err.message }));
+    });
+}
+//# sourceMappingURL=glm-naruto-targeted-checks.js.map

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

@@ -40,6 +40,14 @@ export async function writeMissionArtifacts(input) {
         await writeJsonAtomic(path.join(dir, 'apply-result.json'), sanitizeArtifact(input.applyResult));
     if (input.applyTransaction)
         await writeJsonAtomic(path.join(dir, 'apply-transaction.json'), sanitizeArtifact(input.applyTransaction));
+    if (input.mergePlan) {
+        await writeTextAtomic(path.join(dir, 'merge-rationale.md'), renderMergeRationale({
+            mergePlan: input.mergePlan,
+            conflictGraph: input.conflictGraph,
+            candidateScoreboard: input.candidateScoreboard,
+            applyTransaction: input.applyTransaction
+        }));
+    }
     if (input.verificationSummary)
         await writeJsonAtomic(path.join(dir, 'verification-summary.json'), sanitizeArtifact(input.verificationSummary));
     if (input.missionResult)
@@ -85,6 +93,48 @@ export async function writeMissionArtifacts(input) {
     }
     return dir;
 }
+function renderMergeRationale(input) {
+    const plan = input.mergePlan;
+    const graph = input.conflictGraph;
+    const scoreboard = input.candidateScoreboard;
+    const tx = input.applyTransaction;
+    const selected = Array.isArray(plan?.selected_patches) ? plan.selected_patches : [];
+    const scores = Array.isArray(scoreboard?.scores) ? scoreboard.scores : [];
+    const edges = Array.isArray(graph?.edges) ? graph.edges : [];
+    const rejected = scores
+        .filter((score) => !selected.includes(score.patch_id))
+        .map((score) => `- ${score.patch_id}: score=${score.total_score}; disqualified=${Boolean(score.disqualified)}; reasons=${(score.disqualification_reasons || []).join(', ') || 'none'}`);
+    const selectedRows = selected.map((patchId) => {
+        const score = scores.find((row) => row.patch_id === patchId);
+        return `- ${patchId}: score=${score?.total_score ?? 'n/a'}; components=${JSON.stringify(score?.components ?? {})}`;
+    });
+    const conflictRows = edges.map((edge) => `- ${edge.left_patch_id} vs ${edge.right_patch_id}: ${edge.reason}`);
+    return [
+        '# GLM Naruto Merge Rationale',
+        '',
+        `Mission: ${plan?.mission_id ?? 'unknown'}`,
+        `Strategy: ${plan?.strategy ?? 'unknown'}`,
+        `Rationale: ${plan?.rationale ?? 'not_recorded'}`,
+        '',
+        '## Selected Patch IDs',
+        selectedRows.length ? selectedRows.join('\n') : '- none',
+        '',
+        '## Rejected Patch IDs',
+        rejected.length ? rejected.join('\n') : '- none',
+        '',
+        '## Conflicts',
+        conflictRows.length ? conflictRows.join('\n') : '- none',
+        '',
+        '## Apply Transaction',
+        `- final_status: ${tx?.final_status ?? 'not_attempted'}`,
+        `- apply_passed: ${tx?.apply_passed ?? false}`,
+        `- targeted_checks_passed: ${tx?.targeted_checks_passed ?? null}`,
+        `- rollback_attempted: ${tx?.rollback_attempted ?? false}`,
+        `- rollback_passed: ${tx?.rollback_passed ?? null}`,
+        `- blockers: ${(tx?.blockers || []).join(', ') || 'none'}`,
+        ''
+    ].join('\n');
+}
 function sanitizeArtifact(value) {
     return JSON.parse(JSON.stringify(value, (key, raw) => {
         if (isSecretLikeKey(key) && typeof raw === 'string' && raw.trim() && !isAllowedRedaction(raw))

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.12';
 //# sourceMappingURL=version.js.map

package/package.json

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