sneakoscope 4.0.9 → 4.0.11

package/README.md

@@ -35,7 +35,15 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-SKS **4.0.8** makes the GLM 5.2 MAD path bounded by default: `sks --mad --glm` now returns readiness/status and exits when no task is supplied, while task forms use a direct GLM-only speed path with loop guards, request timeouts, and deterministic patch gates. Ordinary `sks --mad`, Naruto/Team, and non-GLM Codex paths keep their existing defaults.
+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.
+
+What changed in 4.0.11:
+
+- **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.
 
 What changed in 4.0.8:
 

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

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

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '4.0.9';
+const FAST_PACKAGE_VERSION = '4.0.11';
 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.9';
+export const PACKAGE_VERSION = '4.0.11';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/pipeline-internals/runtime-gates.js

@@ -236,7 +236,9 @@ export async function evaluateStop(root, state, payload, opts = {}) {
     if (state?.mission_id && state?.stop_gate && !['none', 'honest_mode', 'clarification-gate'].includes(state.stop_gate)) {
         // 4.0.9: Use canonical stop-gate resolver first for NARUTO/GLM_NARUTO routes.
         const modeUpper = String(state?.mode || '').toUpperCase();
-        if (modeUpper === 'NARUTO' || state.stop_gate === 'stop-gate.json' || state.stop_gate === 'naruto-gate.json') {
+        const routeUpper = String(state?.route || state?.route_command || '').replace(/^\$/, '').toUpperCase();
+        const narutoFamily = modeUpper === 'NARUTO' || routeUpper === 'NARUTO' || routeUpper === 'GLM_NARUTO';
+        if (narutoFamily || state.stop_gate === 'stop-gate.json' || state.stop_gate === 'naruto-gate.json') {
             const stopCheck = await checkStopGate({
                 root,
                 route: state.route || state.mode,
@@ -244,7 +246,8 @@ export async function evaluateStop(root, state, payload, opts = {}) {
                 explicitGatePath: typeof state.stop_gate_abs_path === 'string' && state.stop_gate_abs_path ? state.stop_gate_abs_path : undefined,
             });
             if (stopCheck.action === 'allow_stop') {
-                // Gate passed via canonical resolver; fall through to remaining checks.
+                if (narutoFamily)
+                    return { continue: true, systemMessage: `SKS: canonical stop-gate passed at ${stopCheck.gate_path}` };
             }
             else if (stopCheck.action === 'hard_blocked') {
                 return { continue: true, systemMessage: `SKS: ${stopCheck.feedback}` };

package/dist/core/providers/glm/glm-request-cache.js

@@ -3,8 +3,10 @@ import { SksLruCache } from '../../perf/lru-cache.js';
 export function createGlmEncodedRequestCache(maxEntries = 128) {
     return new SksLruCache(maxEntries);
 }
-export function encodeGlmRequestWithCache(request, cache = defaultEncodedRequestCache) {
-    const key = digestRequestForCache(request);
+export function encodeGlmRequestWithCache(input, cache = defaultEncodedRequestCache) {
+    const request = 'request' in input ? input.request : input;
+    const stringify = 'request' in input && input.stringify ? input.stringify : JSON.stringify;
+    const key = 'request' in input && input.cacheKeyParts ? digestRequestCacheKeyParts(input.cacheKeyParts) : digestRequestForCache(request);
     const hit = cache.get(key);
     // Fix 18.2: On cache hit, return stored body without JSON.stringify
     if (hit) {
@@ -12,11 +14,11 @@ export function encodeGlmRequestWithCache(request, cache = defaultEncodedRequest
             return { body: hit.body, entry: hit, cacheHit: true };
         }
         // Even for non-stored bodies, skip re-stringifying by computing from request
-        const body = JSON.stringify(request);
+        const body = stringify(request);
         return { body, entry: hit, cacheHit: true };
     }
     // Cache miss: stringify once
-    const body = JSON.stringify(request);
+    const body = stringify(request);
     if (containsSecretLikeContent(body)) {
         const entry = {
             key,
@@ -40,6 +42,9 @@ export function encodeGlmRequestWithCache(request, cache = defaultEncodedRequest
     cache.set(key, entry);
     return { body, entry, cacheHit: false };
 }
+export function digestRequestCacheKeyParts(parts) {
+    return crypto.createHash('sha256').update(stableStringify(parts)).digest('hex');
+}
 export function digestRequestForCache(request) {
     const safe = {
         model: request.model,

package/dist/core/providers/glm/naruto/glm-naruto-apply-transaction.js

@@ -0,0 +1,90 @@
+import { spawn } from 'node:child_process';
+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';
+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 patchPath = path.join(input.artifactDir, 'selected-combined.patch');
+    await writeTextAtomic(patchPath, patch);
+    const blockers = [];
+    let applyCheckPassed = false;
+    let applyPassed = false;
+    let rollbackAttempted = false;
+    let rollbackPassed = null;
+    let finalStatus = 'blocked';
+    if (!patch.trim()) {
+        blockers.push('combined_patch_empty');
+    }
+    else {
+        const checked = await gitApply(input.cwd, patch, ['apply', '--check', '--whitespace=nowarn', '-']);
+        applyCheckPassed = checked.code === 0;
+        if (!applyCheckPassed)
+            blockers.push(checked.stderr || checked.stdout || 'git_apply_check_failed');
+        if (applyCheckPassed) {
+            const applied = await gitApply(input.cwd, patch, ['apply', '--whitespace=nowarn', '-']);
+            applyPassed = applied.code === 0;
+            if (applyPassed) {
+                finalStatus = 'applied';
+            }
+            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');
+            }
+        }
+    }
+    const postDiff = await gitText(input.cwd, ['diff', '--binary']);
+    const transaction = {
+        schema: 'sks.glm-naruto-apply-transaction.v1',
+        mission_id: input.missionId,
+        selected_patch_ids: input.selectedPatchIds,
+        touched_paths: parsed.touchedPaths,
+        pre_status: preStatus,
+        pre_diff_sha256: sha256(preDiff),
+        combined_patch_sha256: sha256(patch),
+        apply_check_passed: applyCheckPassed,
+        apply_passed: applyPassed,
+        targeted_checks_passed: null,
+        rollback_attempted: rollbackAttempted,
+        rollback_passed: rollbackPassed,
+        final_status: finalStatus,
+        blockers
+    };
+    await writeJsonAtomic(path.join(input.artifactDir, 'apply-transaction.json'), transaction);
+    await writeJsonAtomic(path.join(input.artifactDir, 'apply-transaction-diff-hashes.json'), {
+        schema: 'sks.glm-naruto-apply-transaction-diff-hashes.v1',
+        mission_id: input.missionId,
+        pre_diff_sha256: sha256(preDiff),
+        post_diff_sha256: sha256(postDiff),
+        combined_patch_sha256: sha256(patch)
+    });
+    return { ok: finalStatus === 'applied', applied: finalStatus === 'applied' ? input.selectedPatchIds : [], patch, transaction };
+}
+function gitText(cwd, args) {
+    return new Promise((resolve) => {
+        const child = spawn('git', [...args], { cwd, stdio: ['ignore', 'pipe', 'ignore'] });
+        let stdout = '';
+        child.stdout.on('data', (chunk) => { stdout += String(chunk); });
+        child.on('close', () => resolve(stdout));
+    });
+}
+function gitApply(cwd, patch, args) {
+    return new Promise((resolve) => {
+        const child = spawn('git', [...args], { cwd, stdio: ['pipe', '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.stdin.end(patch);
+    });
+}
+//# sourceMappingURL=glm-naruto-apply-transaction.js.map

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

@@ -1,6 +1,11 @@
-import { nowIso, writeJsonAtomic } from '../../../fsx.js';
+import { nowIso } 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 { 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 = []) {
     const live = args.includes('--live');
     const execute = args.includes('--execute');
@@ -11,7 +16,7 @@ export async function runGlmNarutoBench(root, args = []) {
     if (!live) {
         return {
             schema: 'sks.glm-naruto-bench.v1',
-            version: '4.0.9',
+            version: '4.0.11',
             generated_at: nowIso(),
             status: 'dry_run',
             model: GLM_52_OPENROUTER_MODEL,
@@ -27,29 +32,67 @@ export async function runGlmNarutoBench(root, args = []) {
             warnings: ['dry_run_no_live_api_calls']
         };
     }
-    // Live bench would require OpenRouter key and real API calls
+    const key = await resolveOpenRouterApiKey({ env: process.env });
+    if (!key.key)
+        return blocked(root, ['live_bench_requires_openrouter_key']);
+    const fixture = await fsp.mkdtemp(path.join(os.tmpdir(), 'sks-glm-naruto-live-bench-'));
+    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 = [];
+    for (const workers of [1, 4, 8, 12]) {
+        const caseStarted = Date.now();
+        const result = await runGlmNarutoMission({
+            cwd: fixture,
+            task: 'Change src/bench-target.ts so value is 2. Return the smallest patch only.',
+            args: ['--bench', '--live', '--no-apply'],
+            missionId: `glm-naruto-live-bench-${workers}-${Date.now()}`,
+            maxWorkers: workers,
+            noApply: true
+        });
+        const traces = await readWorkerTraces(result.artifact_dir);
+        const metrics = summarizeGlmNarutoWorkerMetrics(traces);
+        cases.push({
+            name: workers === 1 ? 'direct single GLM' : `GLM Naruto ${workers} workers`,
+            workers,
+            wall_clock_ms: Date.now() - caseStarted,
+            p50_ttft_ms: metrics.p50_ttft_ms,
+            p90_ttft_ms: metrics.p90_ttft_ms,
+            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,
+            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,
+            workers_completed: metrics.workers_completed,
+            workers_failed: metrics.workers_failed
+        });
+    }
     return {
         schema: 'sks.glm-naruto-bench.v1',
-        version: '4.0.9',
+        version: '4.0.11',
         generated_at: nowIso(),
-        status: 'blocked',
+        status: 'live',
         model: GLM_52_OPENROUTER_MODEL,
         gpt_fallback_allowed: false,
+        cases,
         summary: {
-            simulated_workers: 0,
-            simulated_waves: 0,
-            simulated_patch_candidates: 0,
-            simulated_gate_passed: 0,
-            simulated_mergeable: 0,
+            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_mergeable: cases.filter((row) => row.merge_success).length,
             wall_clock_ms: Date.now() - started
         },
-        warnings: ['live_bench_requires_openrouter_key_and_task']
+        warnings: ['live_bench_no_apply_temp_repo']
     };
 }
 function blocked(root, warnings) {
     return {
         schema: 'sks.glm-naruto-bench.v1',
-        version: '4.0.9',
+        version: '4.0.11',
         generated_at: nowIso(),
         status: 'blocked',
         model: GLM_52_OPENROUTER_MODEL,
@@ -65,4 +108,14 @@ function blocked(root, warnings) {
         warnings
     };
 }
+async function readWorkerTraces(artifactDir) {
+    if (!artifactDir)
+        return [];
+    try {
+        return JSON.parse(await fsp.readFile(path.join(artifactDir, 'worker-traces.json'), 'utf8'));
+    }
+    catch {
+        return [];
+    }
+}
 //# sourceMappingURL=glm-naruto-bench.js.map

package/dist/core/providers/glm/naruto/glm-naruto-combined-patch.js

@@ -0,0 +1,49 @@
+import { checkAndApplyGlmPatch } from '../glm-patch-apply.js';
+export function combineGlmNarutoPatches(envelopes, selectedPatchIds) {
+    const selected = selectedPatchIds
+        .map((patchId) => envelopes.find((env) => env.worker_id === patchId || env.patch_sha256 === patchId))
+        .filter((env) => Boolean(env))
+        .sort((a, b) => a.worker_id.localeCompare(b.worker_id));
+    return mergeDiffSections(selected.flatMap((env) => splitDiffSections(env.patch)));
+}
+export async function checkAndApplyCombinedGlmNarutoPatch(input) {
+    const patch = combineGlmNarutoPatches(input.envelopes, input.selectedPatchIds);
+    if (!patch.trim())
+        return { ok: false, patch, applied: [], blocker: 'combined_patch_empty' };
+    const checked = await checkAndApplyGlmPatch({ cwd: input.cwd, patch, apply: input.apply });
+    if (!checked.ok)
+        return { ok: false, patch, applied: [], blocker: checked.error.code };
+    return { ok: true, patch, applied: input.selectedPatchIds };
+}
+function mergeDiffSections(sections) {
+    const byFile = new Map();
+    for (const section of sections)
+        byFile.set(section.file, [...(byFile.get(section.file) || []), section]);
+    const merged = [];
+    for (const [file] of byFile) {
+        const group = byFile.get(file);
+        const first = group[0];
+        merged.push([...first.header, ...group.flatMap((section) => section.hunks)].join('\n').trimEnd());
+    }
+    return merged.filter(Boolean).join('\n\n') + (merged.length ? '\n' : '');
+}
+function splitDiffSections(patch) {
+    const rawSections = patch
+        .split(/(?=^diff --git )/m)
+        .map((section) => section.trim())
+        .filter(Boolean);
+    return rawSections.map((section) => {
+        const lines = section.split(/\r?\n/);
+        const diff = lines[0]?.match(/^diff --git a\/(.+?) b\/(.+)$/);
+        const file = diff?.[2] || diff?.[1] || lines[0] || 'unknown';
+        const firstHunk = lines.findIndex((line) => line.startsWith('@@ '));
+        if (firstHunk < 0)
+            return { file, header: lines, hunks: [] };
+        return {
+            file,
+            header: lines.slice(0, firstHunk),
+            hunks: lines.slice(firstHunk)
+        };
+    });
+}
+//# sourceMappingURL=glm-naruto-combined-patch.js.map

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

@@ -2,7 +2,6 @@ import { flag, readOption, positionalArgs } from '../../../../cli/args.js';
 import { printJson } from '../../../../cli/output.js';
 import { runGlmNarutoMission } from './glm-naruto-orchestrator.js';
 import { runGlmNarutoBench } from './glm-naruto-bench.js';
-import { resolveOpenRouterApiKey } from '../../openrouter/openrouter-secret-store.js';
 export async function glmNarutoCommand(args = []) {
     if (flag(args, '--bench')) {
         const result = await runGlmNarutoBench(process.cwd(), args);
@@ -36,34 +35,17 @@ export async function glmNarutoCommand(args = []) {
         process.exitCode = 1;
         return result;
     }
-    const key = await resolveOpenRouterApiKey({ env: process.env });
-    if (!key.key) {
-        const result = {
-            schema: 'sks.glm-naruto-result.v1',
-            ok: false,
-            status: 'blocked',
-            mission_id: 'none',
-            task,
-            model: 'z-ai/glm-5.2',
-            gpt_fallback_allowed: false,
-            termination_reason: 'glm_missing_openrouter_key',
-            blockers: ['glm_missing_openrouter_key'],
-            warnings: ['set_OPENROUTER_API_KEY_or_run_sks_--mad_--glm_--repair']
-        };
-        if (flag(args, '--json'))
-            printJson(result);
-        else
-            console.error('GLM Naruto blocked: missing OpenRouter API key. Run: sks --mad --glm --repair');
-        process.exitCode = 1;
-        return result;
-    }
     const maxWorkers = parseInt(readOption(args, '--clones', readOption(args, '--workers', '12')), 10) || 12;
     const deep = flag(args, '--deep');
     const useJudge = flag(args, '--judge');
     const xhighFinalizer = flag(args, '--xhigh-finalizer');
     const useWorktree = flag(args, '--worktree');
     const patchEnvelopeOnly = flag(args, '--patch-envelope-only');
+    const keepWorktrees = flag(args, '--keep-worktrees');
+    const cleanupWorktrees = flag(args, '--cleanup-worktrees') || !keepWorktrees;
+    const allowPatchEnvelopeFallback = flag(args, '--allow-patch-envelope-fallback');
     const noApply = flag(args, '--no-apply');
+    const skipVerifier = flag(args, '--skip-verifier');
     const mergeStrategy = readOption(args, '--merge-strategy', 'deterministic');
     const result = await runGlmNarutoMission({
         cwd: process.cwd(),
@@ -74,7 +56,12 @@ export async function glmNarutoCommand(args = []) {
         useJudge,
         xhighFinalizer,
         useWorktree: useWorktree && !patchEnvelopeOnly,
+        patchEnvelopeOnly,
+        allowPatchEnvelopeFallback,
+        keepWorktrees,
+        cleanupWorktrees,
         noApply: noApply || flag(args, '--dry-run'),
+        skipVerifier,
         mergeStrategy
     });
     if (flag(args, '--json')) {

package/dist/core/providers/glm/naruto/glm-naruto-concurrency-governor.js

@@ -2,24 +2,25 @@ import { GLM_NARUTO_DEFAULTS } from './glm-naruto-types.js';
 export function decideConcurrency(input) {
     const maxClones = Math.min(input.operatorMax || GLM_NARUTO_DEFAULTS.max_clones, GLM_NARUTO_DEFAULTS.max_clones);
     const requested = Math.min(input.requestedClones || GLM_NARUTO_DEFAULTS.default_clones, maxClones);
-    if (input.rateLimited429 > 0.05 || input.ttftP90Ms > 15_000) {
+    const active = input.activeWorkers > 0 ? input.activeWorkers : Math.min(requested, GLM_NARUTO_DEFAULTS.safe_active_start);
+    if (input.failureRate > 0.10) {
         return {
-            target_active_workers: Math.max(1, Math.floor(input.activeWorkers * 0.5)),
+            target_active_workers: 0,
             burst_workers: 0,
             backpressure: true,
-            reason: 'scale_down_high_latency_or_rate_limit'
+            reason: 'pause_high_5xx_or_failure_rate'
         };
     }
-    if (input.failureRate > 0.3) {
+    if (input.rateLimited429 > 0 || input.ttftP90Ms > 15_000) {
         return {
-            target_active_workers: Math.max(1, Math.floor(input.activeWorkers * 0.7)),
+            target_active_workers: Math.max(1, Math.floor(active * 0.5)),
             burst_workers: 0,
             backpressure: true,
-            reason: 'scale_down_high_failure_rate'
+            reason: 'scale_down_high_latency_or_rate_limit'
         };
     }
-    if (input.ttftP90Ms < 5_000 && input.rateLimited429 === 0 && input.activeWorkers < requested) {
-        const target = Math.min(requested, input.activeWorkers + Math.max(1, Math.floor(requested * 0.2)));
+    if (input.ttftP90Ms < 5_000 && input.rateLimited429 === 0 && input.failureRate < 0.05 && active < requested) {
+        const target = Math.min(requested, active + 2);
         return {
             target_active_workers: target,
             burst_workers: Math.min(2, requested - target),
@@ -28,7 +29,7 @@ export function decideConcurrency(input) {
         };
     }
     return {
-        target_active_workers: Math.min(input.activeWorkers, requested),
+        target_active_workers: Math.min(active, requested),
         burst_workers: 0,
         backpressure: false,
         reason: 'steady_state'

package/dist/core/providers/glm/naruto/glm-naruto-conflict-graph.js

@@ -1,3 +1,4 @@
+import { envelopesHaveHunkConflict } from './glm-naruto-hunk-conflict.js';
 export function buildConflictGraph(envelopes, nodes) {
     const edges = [];
     for (let i = 0; i < nodes.length; i++) {
@@ -23,11 +24,16 @@ function detectConflict(left, right, envelopes) {
     if (leftEnv && rightEnv && leftEnv.base_digest !== rightEnv.base_digest) {
         return { left_patch_id: left.patch_id, right_patch_id: right.patch_id, reason: 'base_digest_mismatch' };
     }
+    if (left.shard_id === right.shard_id) {
+        return { left_patch_id: left.patch_id, right_patch_id: right.patch_id, reason: 'same_hunk' };
+    }
     const leftPaths = new Set(left.target_paths);
     const rightPaths = new Set(right.target_paths);
     const sharedFiles = [...leftPaths].filter((p) => rightPaths.has(p));
     if (sharedFiles.length > 0) {
-        if (left.shard_id === right.shard_id) {
+        if (leftEnv && rightEnv) {
+            if (!envelopesHaveHunkConflict(leftEnv, rightEnv))
+                return null;
             return { left_patch_id: left.patch_id, right_patch_id: right.patch_id, reason: 'same_hunk' };
         }
         return { left_patch_id: left.patch_id, right_patch_id: right.patch_id, reason: 'same_file' };

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

@@ -5,9 +5,32 @@ export function decomposeTask(input) {
     const dependencies = [];
     const mutableShardIds = [];
     const verificationShardIds = [];
-    const paths = input.mentionedPaths.length > 0
-        ? input.mentionedPaths
-        : ['src/'];
+    const paths = discoverTargetPaths(input);
+    if (paths.length === 0) {
+        const scoutShard = {
+            id: 'shard-scout-paths',
+            kind: 'verification',
+            task: `Discover target paths before mutation for: ${input.task}`,
+            target_paths: [],
+            forbidden_paths: ['.github/', 'dist/', 'node_modules/'],
+            base_digest: digestBase(input),
+            strategy: 'minimal_patch',
+            patches_per_shard: 0,
+            max_tokens: 2048,
+            reasoning: 'low',
+            mutable: false
+        };
+        return {
+            schema: 'sks.glm-naruto-work-graph.v1',
+            mission_id: input.missionId,
+            task: input.task,
+            shards: [scoutShard],
+            dependencies,
+            parallel_groups: [],
+            mutable_shards: [],
+            verification_shards: [scoutShard.id]
+        };
+    }
     let shardIndex = 0;
     for (const targetPath of paths) {
         const shardId = `shard-${shardIndex}`;
@@ -64,6 +87,33 @@ export function decomposeTask(input) {
         verification_shards: verificationShardIds
     };
 }
+function discoverTargetPaths(input) {
+    const candidates = new Set();
+    for (const mentioned of input.mentionedPaths)
+        candidates.add(mentioned);
+    for (const line of (input.gitStatus || '').split(/\r?\n/)) {
+        const match = line.match(/^\s*(?:[AMDRCU?!]{1,2})\s+(.+)$/);
+        if (!match)
+            continue;
+        const file = match[1].split(/\s+->\s+/).pop().trim();
+        if (isMutableCandidate(file))
+            candidates.add(file);
+    }
+    for (const source of [input.task, input.lastError || '']) {
+        for (const match of source.matchAll(/\b([A-Za-z0-9_.-]+\/[A-Za-z0-9_./-]+\.(?:ts|tsx|js|mjs|cjs|json|md|yml|yaml|toml))\b/g)) {
+            if (isMutableCandidate(match[1]))
+                candidates.add(match[1]);
+        }
+    }
+    return [...candidates];
+}
+function isMutableCandidate(file) {
+    return Boolean(file)
+        && !file.startsWith('.github/')
+        && !file.startsWith('dist/')
+        && !file.startsWith('node_modules/')
+        && !file.endsWith('/');
+}
 function classifyShardKind(path) {
     if (path.includes('test') || path.includes('__tests__') || path.includes('.test.'))
         return 'test_fix';
@@ -87,7 +137,7 @@ export function validateWorkGraph(graph, isVerifyOnly) {
         return { ok: true };
     const mutableCount = graph.mutable_shards.length;
     if (mutableCount === 0)
-        return { ok: false, reason: 'glm_naruto_invalid_verify_only_plan' };
+        return { ok: false, reason: 'glm_naruto_needs_target_path_context' };
     // Check ratio of mutable shards to total shards (excluding verification shards from the denominator)
     const totalWorkShards = graph.shards.filter(s => s.mutable || s.kind !== 'verification').length;
     const ratio = totalWorkShards > 0 ? mutableCount / totalWorkShards : 0;

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

@@ -15,6 +15,7 @@ export function finalizeMergePlan(input) {
     return planMerge({
         missionId: input.missionId,
         graph: conflictGraph,
+        ...(input.scoreboard ? { scoreboard: input.scoreboard } : {}),
         strategy,
         ...(input.judgeResult ? { judgeRanking: input.judgeResult.ranked_patch_ids } : {})
     });

package/dist/core/providers/glm/naruto/glm-naruto-hunk-conflict.js

@@ -0,0 +1,16 @@
+import { hunksOverlap, parseUnifiedDiffHunks } from './glm-naruto-hunk-parser.js';
+export function envelopesHaveHunkConflict(left, right) {
+    const leftHunks = parseUnifiedDiffHunks(left.patch);
+    const rightHunks = parseUnifiedDiffHunks(right.patch);
+    if (leftHunks.length === 0 || rightHunks.length === 0)
+        return sharesPath(left, right);
+    return leftHunks.some((leftHunk) => rightHunks.some((rightHunk) => hunksOverlap(leftHunk, rightHunk)));
+}
+export function envelopesShareFileButNotHunk(left, right) {
+    return sharesPath(left, right) && !envelopesHaveHunkConflict(left, right);
+}
+function sharesPath(left, right) {
+    const rightPaths = new Set(right.target_paths);
+    return left.target_paths.some((file) => rightPaths.has(file));
+}
+//# sourceMappingURL=glm-naruto-hunk-conflict.js.map

package/dist/core/providers/glm/naruto/glm-naruto-hunk-parser.js

@@ -0,0 +1,36 @@
+export function parseUnifiedDiffHunks(patch) {
+    const hunks = [];
+    let currentFile = null;
+    for (const line of patch.split(/\r?\n/)) {
+        const diff = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+        if (diff?.[2]) {
+            currentFile = diff[2];
+            continue;
+        }
+        const file = line.match(/^\+\+\+ b\/(.+)$/);
+        if (file?.[1] && file[1] !== '/dev/null')
+            currentFile = file[1];
+        const hunk = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/);
+        if (hunk && currentFile) {
+            hunks.push({
+                file: currentFile,
+                old_start: Number(hunk[1]),
+                old_lines: Number(hunk[2] || 1),
+                new_start: Number(hunk[3]),
+                new_lines: Number(hunk[4] || 1),
+                header: line
+            });
+        }
+    }
+    return hunks;
+}
+export function hunksOverlap(left, right) {
+    if (left.file !== right.file)
+        return false;
+    return rangesOverlap(left.old_start, left.old_start + Math.max(1, left.old_lines) - 1, right.old_start, right.old_start + Math.max(1, right.old_lines) - 1)
+        || rangesOverlap(left.new_start, left.new_start + Math.max(1, left.new_lines) - 1, right.new_start, right.new_start + Math.max(1, right.new_lines) - 1);
+}
+function rangesOverlap(aStart, aEnd, bStart, bEnd) {
+    return aStart <= bEnd && bStart <= aEnd;
+}
+//# sourceMappingURL=glm-naruto-hunk-parser.js.map