sneakoscope 4.0.6 → 4.0.8

package/README.md

@@ -35,11 +35,15 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-SKS **4.0.6** 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.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.
+
+What changed in 4.0.8:
+
+- **`--open` alias for interactive GLM launch.** `sks --mad --glm --open` now opens the GLM interactive Zellij runtime, equivalent to `sks --mad --glm --interactive`.
 
 What changed in 4.0.6:
 
-- **No default long-lived GLM launch.** Bare `sks --mad --glm` no longer falls through to MAD/Zellij; `--interactive`, `--zellij`, or `session` is required for that path.
+- **No default long-lived GLM launch.** Bare `sks --mad --glm` no longer falls through to MAD/Zellij; `--interactive`, `--open`, `--zellij`, or `session` is required for that path.
 - **Fast GLM speed profile.** Speed mode keeps OpenRouter locked to `z-ai/glm-5.2`, disables GPT/model fallback, avoids high/xhigh reasoning by default, and uses `provider.require_parameters: false` with throughput-first routing.
 - **Bounded direct task runs.** `sks --mad --glm run "task"` and `sks --mad --glm "task"` use a one-shot GLM speed run with max-turn, wall-clock, request-timeout, no-progress, repeated-output, and terminal-state guards.
 - **Deterministic mutation gate.** GLM still returns patch envelopes; SKS parses the unified diff, blocks protected paths, runs `git apply --check`, and applies only after the gate passes.

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

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

package/dist/core/commands/glm-command.js

@@ -4,8 +4,13 @@ import { printJson } from '../../cli/output.js';
 import { runGlmDirectSpeedRun } from '../providers/glm/glm-direct-run.js';
 import { runGlmReadinessAndExit } from '../providers/glm/glm-readiness.js';
 import { runGlmInteractiveLaunch } from '../providers/glm/glm-interactive-launch.js';
+import { glmNarutoCommand } from '../providers/glm/naruto/glm-naruto-command.js';
 export async function glmCommand(args = []) {
-    if (flag(args, '--bench')) {
+    if (flag(args, '--naruto') || positionalArgs(args)[0] === 'naruto') {
+        const narutoArgs = args.filter((a) => a !== '--naruto' && a !== 'naruto');
+        return glmNarutoCommand(narutoArgs);
+    }
+    if (flag(args, '--bench') && !flag(args, '--naruto')) {
         const result = await runGlmBench(process.cwd(), args);
         if (result.status === 'blocked')
             process.exitCode = 1;
@@ -18,7 +23,7 @@ export async function glmCommand(args = []) {
         return result;
     }
     const task = extractGlmTask(args);
-    const interactive = flag(args, '--interactive') || flag(args, '--zellij') || positionalArgs(args)[0] === 'session';
+    const interactive = flag(args, '--interactive') || flag(args, '--open') || flag(args, '--zellij') || positionalArgs(args)[0] === 'session';
     if (interactive) {
         const readiness = await runGlmReadinessAndExit(args);
         if (!readiness.ok)
@@ -50,6 +55,8 @@ function extractGlmTask(args) {
         return positional.slice(1).join(' ').trim() || null;
     if (positional[0] === 'session')
         return null;
+    if (positional[0] === 'naruto')
+        return null;
     return positional.join(' ').trim() || null;
 }
 //# sourceMappingURL=glm-command.js.map

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.6';
+export const PACKAGE_VERSION = '4.0.8';
 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/glm-bench.js

@@ -14,7 +14,7 @@ export async function runGlmBench(root, args = []) {
     if (execute && !live) {
         const blocked = {
             schema: 'sks.glm-bench-result.v1',
-            version: '4.0.6',
+            version: '4.0.8',
             generated_at: nowIso(),
             status: 'blocked',
             dry_run: true,
@@ -32,7 +32,7 @@ export async function runGlmBench(root, args = []) {
     if (live) {
         const blocked = {
             schema: 'sks.glm-bench-result.v1',
-            version: '4.0.6',
+            version: '4.0.8',
             generated_at: nowIso(),
             status: 'blocked',
             dry_run: false,
@@ -50,7 +50,7 @@ export async function runGlmBench(root, args = []) {
     if (execute) {
         const blocked = {
             schema: 'sks.glm-bench-result.v1',
-            version: '4.0.6',
+            version: '4.0.8',
             generated_at: nowIso(),
             status: 'blocked',
             dry_run: true,
@@ -69,7 +69,7 @@ export async function runGlmBench(root, args = []) {
     const deepTotals = SYNTHETIC_CASES.map((row) => row.deep.total_ms);
     const result = {
         schema: 'sks.glm-bench-result.v1',
-        version: '4.0.6',
+        version: '4.0.8',
         generated_at: nowIso(),
         status: 'dry_run',
         dry_run: true,

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

@@ -3,7 +3,7 @@ import { nowIso, writeJsonAtomic } from '../../fsx.js';
 export function createEmptyGlmLatencyTrace(mode) {
     return {
         schema: 'sks.glm-latency-trace.v1',
-        version: '4.0.6',
+        version: '4.0.8',
         mode,
         total_ms: 0,
         preflight_ms: 0,

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

@@ -6,9 +6,17 @@ export function createGlmEncodedRequestCache(maxEntries = 128) {
 export function encodeGlmRequestWithCache(request, cache = defaultEncodedRequestCache) {
     const key = digestRequestForCache(request);
     const hit = cache.get(key);
+    // Fix 18.2: On cache hit, return stored body without JSON.stringify
+    if (hit) {
+        if (hit.bodyStored) {
+            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);
+        return { body, entry: hit, cacheHit: true };
+    }
+    // Cache miss: stringify once
     const body = JSON.stringify(request);
-    if (hit)
-        return { body: hit.bodyStored ? hit.body : body, entry: hit, cacheHit: true };
     if (containsSecretLikeContent(body)) {
         const entry = {
             key,

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

@@ -0,0 +1,2 @@
+export { writeMissionArtifacts, createMissionTrace, recordWorkerTrace, buildMissionSummary } from './glm-naruto-trace.js';
+//# sourceMappingURL=glm-naruto-artifacts.js.map

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

@@ -0,0 +1,68 @@
+import { nowIso, writeJsonAtomic } from '../../../fsx.js';
+import path from 'node:path';
+import { GLM_52_OPENROUTER_MODEL } from '../glm-52-settings.js';
+export async function runGlmNarutoBench(root, args = []) {
+    const live = args.includes('--live');
+    const execute = args.includes('--execute');
+    const started = Date.now();
+    if (execute && !live) {
+        return blocked(root, ['execute_requires_live_flag']);
+    }
+    if (!live) {
+        return {
+            schema: 'sks.glm-naruto-bench.v1',
+            version: '4.0.8',
+            generated_at: nowIso(),
+            status: 'dry_run',
+            model: GLM_52_OPENROUTER_MODEL,
+            gpt_fallback_allowed: false,
+            summary: {
+                simulated_workers: 12,
+                simulated_waves: 3,
+                simulated_patch_candidates: 24,
+                simulated_gate_passed: 18,
+                simulated_mergeable: 12,
+                wall_clock_ms: Date.now() - started
+            },
+            warnings: ['dry_run_no_live_api_calls']
+        };
+    }
+    // Live bench would require OpenRouter key and real API calls
+    return {
+        schema: 'sks.glm-naruto-bench.v1',
+        version: '4.0.8',
+        generated_at: nowIso(),
+        status: 'blocked',
+        model: GLM_52_OPENROUTER_MODEL,
+        gpt_fallback_allowed: false,
+        summary: {
+            simulated_workers: 0,
+            simulated_waves: 0,
+            simulated_patch_candidates: 0,
+            simulated_gate_passed: 0,
+            simulated_mergeable: 0,
+            wall_clock_ms: Date.now() - started
+        },
+        warnings: ['live_bench_requires_openrouter_key_and_task']
+    };
+}
+function blocked(root, warnings) {
+    return {
+        schema: 'sks.glm-naruto-bench.v1',
+        version: '4.0.8',
+        generated_at: nowIso(),
+        status: 'blocked',
+        model: GLM_52_OPENROUTER_MODEL,
+        gpt_fallback_allowed: false,
+        summary: {
+            simulated_workers: 0,
+            simulated_waves: 0,
+            simulated_patch_candidates: 0,
+            simulated_gate_passed: 0,
+            simulated_mergeable: 0,
+            wall_clock_ms: 0
+        },
+        warnings
+    };
+}
+//# sourceMappingURL=glm-naruto-bench.js.map

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

@@ -0,0 +1,45 @@
+import { GLM_NARUTO_LIMITS } from './glm-naruto-types.js';
+export function createBudget(missionId, deep) {
+    return {
+        missionId,
+        startedMs: Date.now(),
+        wavesCompleted: 0,
+        totalRequests: 0,
+        requestsPerShard: new Map(),
+        noProgressWaves: 0,
+        repairWaves: 0,
+        mergeAttempts: 0,
+        maxWaves: deep ? GLM_NARUTO_LIMITS.max_waves_deep : GLM_NARUTO_LIMITS.max_waves_speed
+    };
+}
+export function checkBudget(budget) {
+    const elapsed = Date.now() - budget.startedMs;
+    if (elapsed >= GLM_NARUTO_LIMITS.max_wall_clock_ms) {
+        return { ok: false, reason: 'budget_wall_clock_exceeded' };
+    }
+    if (budget.totalRequests >= GLM_NARUTO_LIMITS.max_total_requests) {
+        return { ok: false, reason: 'budget_total_requests_exceeded' };
+    }
+    if (budget.wavesCompleted >= budget.maxWaves) {
+        return { ok: false, reason: 'budget_max_waves_reached' };
+    }
+    if (budget.noProgressWaves > GLM_NARUTO_LIMITS.max_no_progress_waves) {
+        return { ok: false, reason: 'budget_no_progress_waves_exceeded' };
+    }
+    if (budget.repairWaves > GLM_NARUTO_LIMITS.max_repair_waves) {
+        return { ok: false, reason: 'budget_max_repair_waves_exceeded' };
+    }
+    if (budget.mergeAttempts > GLM_NARUTO_LIMITS.max_merge_attempts) {
+        return { ok: false, reason: 'budget_max_merge_attempts_exceeded' };
+    }
+    return { ok: true };
+}
+export function recordRequest(budget, shardId) {
+    const newPerShard = new Map(budget.requestsPerShard);
+    newPerShard.set(shardId, (newPerShard.get(shardId) || 0) + 1);
+    return { ...budget, totalRequests: budget.totalRequests + 1, requestsPerShard: newPerShard };
+}
+export function canRequestShard(budget, shardId) {
+    return (budget.requestsPerShard.get(shardId) || 0) < GLM_NARUTO_LIMITS.max_requests_per_shard;
+}
+//# sourceMappingURL=glm-naruto-budget.js.map

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

@@ -0,0 +1,97 @@
+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);
+        if (flag(args, '--json'))
+            printJson(result);
+        else if (result.status === 'blocked')
+            console.error(`GLM Naruto bench blocked: ${result.warnings.join(', ')}`);
+        else
+            console.log(`GLM Naruto bench: ${result.status} workers=${result.summary.simulated_workers} candidates=${result.summary.simulated_patch_candidates}`);
+        return result;
+    }
+    const positional = positionalArgs(args).map(String);
+    const task = positional.join(' ').trim();
+    if (!task && !flag(args, '--repair') && !flag(args, '--status')) {
+        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: 'no_task_provided',
+            blockers: ['glm_naruto_no_task'],
+            warnings: []
+        };
+        if (flag(args, '--json'))
+            printJson(result);
+        else
+            console.error('GLM Naruto requires a task. Usage: sks --mad --glm --naruto "<task>"');
+        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 noApply = flag(args, '--no-apply');
+    const mergeStrategy = readOption(args, '--merge-strategy', 'deterministic');
+    const result = await runGlmNarutoMission({
+        cwd: process.cwd(),
+        task,
+        args,
+        maxWorkers,
+        deep,
+        useJudge,
+        xhighFinalizer,
+        useWorktree: useWorktree && !patchEnvelopeOnly,
+        noApply: noApply || flag(args, '--dry-run'),
+        mergeStrategy
+    });
+    if (flag(args, '--json')) {
+        printJson(result);
+    }
+    else {
+        const r = result;
+        if (r.ok) {
+            console.log(`GLM Naruto completed: ${r.applied_patches} patches applied, ${r.patch_candidates} candidates, ${r.gate_passed_candidates} gate-passed, ${r.repair_waves} repair waves`);
+            if (r.artifact_dir)
+                console.log(`Artifacts: ${r.artifact_dir}`);
+        }
+        else {
+            console.error(`GLM Naruto ${r.status}: ${r.termination_reason} — blockers: ${r.blockers.join(', ')}`);
+            process.exitCode = 1;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=glm-naruto-command.js.map

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

@@ -0,0 +1,37 @@
+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) {
+        return {
+            target_active_workers: Math.max(1, Math.floor(input.activeWorkers * 0.5)),
+            burst_workers: 0,
+            backpressure: true,
+            reason: 'scale_down_high_latency_or_rate_limit'
+        };
+    }
+    if (input.failureRate > 0.3) {
+        return {
+            target_active_workers: Math.max(1, Math.floor(input.activeWorkers * 0.7)),
+            burst_workers: 0,
+            backpressure: true,
+            reason: 'scale_down_high_failure_rate'
+        };
+    }
+    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)));
+        return {
+            target_active_workers: target,
+            burst_workers: Math.min(2, requested - target),
+            backpressure: false,
+            reason: 'scale_up_low_latency_no_rate_limit'
+        };
+    }
+    return {
+        target_active_workers: Math.min(input.activeWorkers, requested),
+        burst_workers: 0,
+        backpressure: false,
+        reason: 'steady_state'
+    };
+}
+//# sourceMappingURL=glm-naruto-concurrency-governor.js.map

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

@@ -0,0 +1,74 @@
+export function buildConflictGraph(envelopes, nodes) {
+    const edges = [];
+    for (let i = 0; i < nodes.length; i++) {
+        for (let j = i + 1; j < nodes.length; j++) {
+            const left = nodes[i];
+            const right = nodes[j];
+            const conflict = detectConflict(left, right, envelopes);
+            if (conflict)
+                edges.push(conflict);
+        }
+    }
+    return {
+        schema: 'sks.glm-naruto-conflict-graph.v1',
+        nodes,
+        edges
+    };
+}
+function detectConflict(left, right, envelopes) {
+    if (left.patch_id === right.patch_id)
+        return null;
+    const leftEnv = envelopes.find((e) => e.worker_id === left.patch_id || e.patch_sha256 === left.patch_sha256);
+    const rightEnv = envelopes.find((e) => e.worker_id === right.patch_id || e.patch_sha256 === right.patch_sha256);
+    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' };
+    }
+    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) {
+            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' };
+    }
+    return null;
+}
+export function hasConflict(graph, patchId) {
+    return graph.edges.some((edge) => edge.left_patch_id === patchId || edge.right_patch_id === patchId);
+}
+export function getNonConflictingSets(graph) {
+    const passed = graph.nodes.filter((n) => n.gate_passed);
+    if (passed.length === 0)
+        return [];
+    const conflictMap = new Map();
+    for (const node of passed)
+        conflictMap.set(node.patch_id, new Set());
+    for (const edge of graph.edges) {
+        if (conflictMap.has(edge.left_patch_id) && conflictMap.has(edge.right_patch_id)) {
+            conflictMap.get(edge.left_patch_id).add(edge.right_patch_id);
+            conflictMap.get(edge.right_patch_id).add(edge.left_patch_id);
+        }
+    }
+    const results = [];
+    const sorted = [...passed].sort((a, b) => b.score - a.score);
+    const used = new Set();
+    for (const node of sorted) {
+        if (used.has(node.patch_id))
+            continue;
+        const group = [node.patch_id];
+        used.add(node.patch_id);
+        for (const other of sorted) {
+            if (used.has(other.patch_id))
+                continue;
+            const conflicts = conflictMap.get(other.patch_id);
+            if (!group.some((id) => conflicts.has(id))) {
+                group.push(other.patch_id);
+                used.add(other.patch_id);
+            }
+        }
+        results.push(group);
+    }
+    return results;
+}
+//# sourceMappingURL=glm-naruto-conflict-graph.js.map

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

@@ -0,0 +1,99 @@
+import crypto from 'node:crypto';
+import { GLM_NARUTO_DEFAULTS, NARUTO_PATCH_STRATEGIES } from './glm-naruto-types.js';
+export function decomposeTask(input) {
+    const shards = [];
+    const dependencies = [];
+    const mutableShardIds = [];
+    const verificationShardIds = [];
+    const paths = input.mentionedPaths.length > 0
+        ? input.mentionedPaths
+        : ['src/'];
+    let shardIndex = 0;
+    for (const targetPath of paths) {
+        const shardId = `shard-${shardIndex}`;
+        const strategy = NARUTO_PATCH_STRATEGIES[shardIndex % NARUTO_PATCH_STRATEGIES.length] || 'minimal_patch';
+        const isCritical = paths.length <= 2;
+        const shard = {
+            id: shardId,
+            kind: classifyShardKind(targetPath),
+            task: input.task,
+            target_paths: [targetPath],
+            forbidden_paths: ['.github/', 'dist/', 'node_modules/'],
+            base_digest: digestBase(input),
+            strategy,
+            patches_per_shard: isCritical ? GLM_NARUTO_DEFAULTS.critical_patches_per_shard : GLM_NARUTO_DEFAULTS.default_patches_per_shard,
+            max_tokens: GLM_NARUTO_DEFAULTS.default_max_tokens,
+            reasoning: 'none',
+            mutable: true
+        };
+        shards.push(shard);
+        mutableShardIds.push(shardId);
+        shardIndex++;
+    }
+    const verifyShard = {
+        id: 'shard-verify',
+        kind: 'verification',
+        task: `Verify all patches for: ${input.task}`,
+        target_paths: paths,
+        forbidden_paths: ['.github/', 'dist/', 'node_modules/'],
+        base_digest: digestBase(input),
+        strategy: 'minimal_patch',
+        patches_per_shard: 0,
+        max_tokens: 4096,
+        reasoning: 'low',
+        mutable: false
+    };
+    shards.push(verifyShard);
+    verificationShardIds.push(verifyShard.id);
+    for (const mutableId of mutableShardIds) {
+        dependencies.push({ from: mutableId, to: verifyShard.id, kind: 'verifies' });
+    }
+    const parallelGroup = {
+        id: 'parallel-patch-wave',
+        shard_ids: mutableShardIds,
+        parallel: true
+    };
+    return {
+        schema: 'sks.glm-naruto-work-graph.v1',
+        mission_id: input.missionId,
+        task: input.task,
+        shards,
+        dependencies,
+        parallel_groups: [parallelGroup],
+        mutable_shards: mutableShardIds,
+        verification_shards: verificationShardIds
+    };
+}
+function classifyShardKind(path) {
+    if (path.includes('test') || path.includes('__tests__') || path.includes('.test.'))
+        return 'test_fix';
+    if (path.endsWith('.md') || path.endsWith('.txt'))
+        return 'doc_patch';
+    if (path.endsWith('.json') || path.endsWith('.yaml') || path.endsWith('.yml') || path.endsWith('.toml'))
+        return 'config_patch';
+    if (path.endsWith('.ts') || path.endsWith('.js') || path.endsWith('.mjs'))
+        return 'file_patch';
+    return 'file_patch';
+}
+function digestBase(input) {
+    return crypto.createHash('sha256').update(JSON.stringify({
+        task: input.task,
+        gitStatus: input.gitStatus || '',
+        paths: input.mentionedPaths
+    })).digest('hex').slice(0, 16);
+}
+export function validateWorkGraph(graph, isVerifyOnly) {
+    if (isVerifyOnly)
+        return { ok: true };
+    const mutableCount = graph.mutable_shards.length;
+    if (mutableCount === 0)
+        return { ok: false, reason: 'glm_naruto_invalid_verify_only_plan' };
+    // 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;
+    if (ratio < GLM_NARUTO_DEFAULTS.patch_worker_ratio) {
+        return { ok: false, reason: 'glm_naruto_insufficient_patch_workers' };
+    }
+    return { ok: true };
+}
+//# sourceMappingURL=glm-naruto-decomposer.js.map

package/dist/core/providers/glm/naruto/glm-naruto-file-lease.js

@@ -0,0 +1,23 @@
+export function planFileLeases(shardTargetPaths) {
+    const pathToShards = new Map();
+    for (const [shardId, paths] of shardTargetPaths) {
+        for (const p of paths) {
+            const list = pathToShards.get(p) || [];
+            list.push(shardId);
+            pathToShards.set(p, list);
+        }
+    }
+    const leases = [];
+    for (const [path, shardIds] of pathToShards) {
+        leases.push({
+            path,
+            shardIds,
+            exclusive: shardIds.length === 1
+        });
+    }
+    return leases;
+}
+export function hasLeaseConflict(leases, shardId) {
+    return leases.some((lease) => !lease.exclusive && lease.shardIds.includes(shardId));
+}
+//# sourceMappingURL=glm-naruto-file-lease.js.map

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

@@ -0,0 +1,22 @@
+import { planMerge } from './glm-naruto-merge-planner.js';
+import { buildConflictGraph } from './glm-naruto-conflict-graph.js';
+export function finalizeMergePlan(input) {
+    const passedEnvelopes = input.envelopes.filter((e) => e.status === 'gate_passed');
+    const nodes = passedEnvelopes.map((env) => ({
+        patch_id: env.worker_id,
+        shard_id: env.shard_id,
+        target_paths: env.target_paths,
+        score: Math.max(0, 100 - Math.floor(env.patch.length / 100)),
+        gate_passed: true,
+        patch_sha256: env.patch_sha256
+    }));
+    const conflictGraph = buildConflictGraph(passedEnvelopes, nodes);
+    const strategy = input.useJudge && input.judgeResult ? 'judge' : 'deterministic';
+    return planMerge({
+        missionId: input.missionId,
+        graph: conflictGraph,
+        strategy,
+        ...(input.judgeResult ? { judgeRanking: input.judgeResult.ranked_patch_ids } : {})
+    });
+}
+//# sourceMappingURL=glm-naruto-finalizer.js.map