sneakoscope 4.0.7 → 4.0.9

package/README.md

@@ -35,9 +35,9 @@ 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.7:
+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`.
 

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

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

package/dist/cli/command-registry.js

@@ -123,6 +123,7 @@ export const COMMANDS = {
     agent: entry('beta', 'Run native multi-session agent missions', 'dist/core/commands/agent-command.js', argsCommand(() => import('../core/commands/agent-command.js'), 'agentCommand', 'dist/core/commands/agent-command.js')),
     'with-local-llm': entry('beta', 'Enable or inspect local Ollama worker backend', 'dist/core/commands/local-model-command.js', argsCommand(() => import('../core/commands/local-model-command.js'), 'localModelCommand', 'dist/core/commands/local-model-command.js')),
     naruto: entry('labs', 'Run $Naruto shadow-clone swarm (up to 100 parallel sessions)', 'dist/core/commands/naruto-command.js', argsCommand(() => import('../core/commands/naruto-command.js'), 'narutoCommand', 'dist/core/commands/naruto-command.js')),
+    'stop-gate': entry('beta', 'Check canonical stop-gate resolution for a route/mission', 'dist/core/commands/stop-gate-command.js', commandArgsCommand(() => import('../core/commands/stop-gate-command.js'), 'stopGateCommand', 'dist/core/commands/stop-gate-command.js')),
     loop: entry('labs', 'Dynamic Loop Runtime: plan/run/status/proof loop graphs.', 'dist/core/commands/loop-command.js', subcommand(() => import('../core/commands/loop-command.js'), 'loopCommand', 'dist/core/commands/loop-command.js', 'help')),
     'qa-loop': entry('beta', 'Run QA loop missions', 'dist/core/commands/qa-loop-command.js', subcommand(() => import('../core/commands/qa-loop-command.js'), 'qaLoopCommand', 'dist/core/commands/qa-loop-command.js')),
     research: entry('labs', 'Run research missions', 'dist/core/commands/research-command.js', subcommand(() => import('../core/commands/research-command.js'), 'researchCommand', 'dist/core/commands/research-command.js')),

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;
@@ -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/commands/naruto-command.js

@@ -25,6 +25,7 @@ import { evaluateGitWorktreeCapability } from '../git/git-worktree-capability.js
 import { buildRuntimeProofSummary, renderRuntimeProofSummary } from '../agents/runtime-proof-summary.js';
 import { writeCodex0138CapabilityArtifacts } from '../codex-control/codex-0138-capability.js';
 import { writeCodex0139CapabilityArtifacts } from '../codex-control/codex-0139-capability.js';
+import { writeFinalStopGate } from '../stop-gate/stop-gate-writer.js';
 const NARUTO_RESULT_SCHEMA = 'sks.naruto-command-result.v1';
 const NARUTO_ROUTE = '$Naruto';
 // $Naruto — Shadow Clone Swarm (影分身 / Kage Bunshin no Jutsu).
@@ -34,6 +35,11 @@ const NARUTO_ROUTE = '$Naruto';
 // writes). The standard 20-agent ceiling is lifted only for this route.
 export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
     const args = Array.isArray(commandOrArgs) ? commandOrArgs : maybeArgs;
+    // 4.0.9: `sks naruto --glm` delegates to GLM Naruto before legacy Naruto starts.
+    if (args.includes('--glm')) {
+        const { glmNarutoCommand } = await import('../providers/glm/naruto/glm-naruto-command.js');
+        return glmNarutoCommand(args.filter((arg) => arg !== '--glm'));
+    }
     const parsed = parseNarutoArgs(args);
     if (parsed.action === 'help')
         return narutoHelp(parsed);
@@ -450,6 +456,25 @@ async function narutoRun(parsed) {
         stop_gate: 'naruto-gate.json',
         prompt: parsed.prompt
     });
+    // 4.0.9: Write canonical stop-gate artifacts for hook resolution.
+    const narutoGatePassed = result.ok === true && nativeProofOk && finalAccepted && parallelRuntimeOk;
+    await writeFinalStopGate({
+        root,
+        missionId: mission.id,
+        route: 'Naruto',
+        routeCommand: '$Naruto',
+        status: summaryOk ? 'passed' : 'blocked',
+        terminal: summaryOk,
+        terminalState: summaryOk ? 'completed' : 'blocked',
+        evidence: {
+            build_passed: summaryOk,
+            tests_passed: summaryOk,
+            route_evidence_passed: nativeProofOk && finalAccepted,
+            native_session_split_evidence: nativeProofOk ? 'native_agent_proof' : null,
+        },
+        blockers: summaryOk ? [] : [...(result.proof?.blockers || []), ...(parallelRuntimeOk ? [] : ['naruto_parallel_runtime_proof_below_gate'])],
+        nativeGateFile: 'naruto-gate.json',
+    }).catch(() => null);
     const summary = {
         schema: NARUTO_RESULT_SCHEMA,
         ok: summaryOk,

package/dist/core/commands/stop-gate-command.js

@@ -0,0 +1,63 @@
+import { sksRoot } from '../fsx.js';
+import { checkStopGate } from '../stop-gate/stop-gate-check.js';
+export async function stopGateCommand(command, args) {
+    const subcommand = args[0] === 'check' ? 'check' : (args[0] || 'check');
+    const rest = subcommand === 'check' ? args.slice(1) : args;
+    const json = rest.includes('--json');
+    const route = readOption(rest, '--route');
+    const missionId = readOption(rest, '--mission');
+    const gatePath = readOption(rest, '--gate');
+    if (subcommand !== 'check') {
+        const result = {
+            schema: 'sks.stop-gate-command.v1',
+            ok: false,
+            action: 'continue',
+            error: `Unknown subcommand: ${subcommand}. Available: check`,
+        };
+        if (json)
+            console.log(JSON.stringify(result, null, 2));
+        else
+            console.error(`Unknown stop-gate subcommand: ${subcommand}. Use: sks stop-gate check --route Naruto --json`);
+        return result;
+    }
+    const root = await sksRoot();
+    const result = await checkStopGate({
+        root,
+        ...(route ? { route } : {}),
+        ...(missionId ? { missionId } : {}),
+        ...(gatePath ? { explicitGatePath: gatePath } : {}),
+    });
+    if (json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        if (result.action === 'allow_stop') {
+            console.log(`stop-gate: allow_stop — gate passed at ${result.gate_path}`);
+        }
+        else if (result.action === 'hard_blocked') {
+            console.log(`stop-gate: hard_blocked — ${result.feedback}`);
+        }
+        else {
+            console.error(`stop-gate: continue — ${result.feedback}`);
+        }
+        if (result.diagnostics.checked_paths.length > 0) {
+            console.log('Checked paths:');
+            for (const p of result.diagnostics.checked_paths)
+                console.log(`  ${p}`);
+        }
+        if (result.diagnostics.selected_gate_path) {
+            console.log(`Selected gate: ${result.diagnostics.selected_gate_path}`);
+        }
+    }
+    if (result.action === 'continue')
+        process.exitCode = 1;
+    return result;
+}
+function readOption(args, name) {
+    const index = args.indexOf(name);
+    if (index >= 0 && args[index + 1] && !String(args[index + 1]).startsWith('--'))
+        return args[index + 1];
+    const prefixed = args.find((arg) => String(arg).startsWith(name + '='));
+    return prefixed ? prefixed.slice(name.length + 1) : undefined;
+}
+//# sourceMappingURL=stop-gate-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.9';
 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

@@ -17,6 +17,7 @@ import { readAgentGateStatus } from '../agents/agent-gate.js';
 import { MISTAKE_RECALL_ARTIFACT, mistakeRecallGateStatus } from '../mistake-recall.js';
 import { SSOT_GUARD_ARTIFACT, validateSsotGuardArtifact } from '../safety/ssot-guard.js';
 import { validateTeamRuntimeArtifacts } from '../team-dag.js';
+import { checkStopGate } from '../stop-gate/stop-gate-check.js';
 import { clarificationStopReason, context7Evidence, hasContext7DocsEvidence, hasSubagentEvidence, subagentEvidence, } from './runtime-core.js';
 const REFLECTION_ARTIFACT = 'reflection.md';
 const REFLECTION_GATE = 'reflection-gate.json';
@@ -233,10 +234,33 @@ export async function evaluateStop(root, state, payload, opts = {}) {
         return complianceBlock(root, state, `SKS no-question run is not done. Continue autonomously, fix failing checks, update ${gate.file || 'the active gate file'}, and do not ask the user.${missing}`, { gate: gate.file || 'active-gate', missing: gate.missing });
     }
     if (state?.mission_id && state?.stop_gate && !['none', 'honest_mode', 'clarification-gate'].includes(state.stop_gate)) {
-        const gate = await passedActiveGate(root, state);
-        if (!gate.ok) {
-            const missing = gate.missing?.length ? ` Missing gate fields: ${gate.missing.join(', ')}.` : '';
-            return complianceBlock(root, state, `SKS ${state.route_command || state.mode} route cannot stop yet. Pass ${gate.file || state.stop_gate} or record a hard blocker with evidence before finishing.${missing}`, { gate: gate.file || state.stop_gate, missing: gate.missing });
+        // 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 stopCheck = await checkStopGate({
+                root,
+                route: state.route || state.mode,
+                missionId: state.mission_id,
+                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.
+            }
+            else if (stopCheck.action === 'hard_blocked') {
+                return { continue: true, systemMessage: `SKS: ${stopCheck.feedback}` };
+            }
+            else {
+                const missing = stopCheck.diagnostics.missing_fields?.length ? ` Missing gate fields: ${stopCheck.diagnostics.missing_fields.join(', ')}.` : '';
+                const checkedPaths = stopCheck.diagnostics.checked_paths?.length ? ` Checked: ${stopCheck.diagnostics.checked_paths.join(', ')}.` : '';
+                return complianceBlock(root, state, `SKS ${state.route_command || state.mode} route cannot stop yet. Pass ${stopCheck.gate_path || state.stop_gate} or record a hard blocker with evidence before finishing.${missing}${checkedPaths}`, { gate: stopCheck.gate_path || state.stop_gate, missing: stopCheck.diagnostics.missing_fields });
+            }
+        }
+        else {
+            const gate = await passedActiveGate(root, state);
+            if (!gate.ok) {
+                const missing = gate.missing?.length ? ` Missing gate fields: ${gate.missing.join(', ')}.` : '';
+                return complianceBlock(root, state, `SKS ${state.route_command || state.mode} route cannot stop yet. Pass ${gate.file || state.stop_gate} or record a hard blocker with evidence before finishing.${missing}`, { gate: gate.file || state.stop_gate, missing: gate.missing });
+            }
         }
     }
     const proofGate = await routeProofGateStatus(root, state);

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.9',
             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.9',
             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.9',
             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.9',
         generated_at: nowIso(),
         status: 'dry_run',
         dry_run: true,

package/dist/core/providers/glm/glm-direct-run.js

@@ -60,7 +60,7 @@ export async function runGlmDirectSpeedRun(input) {
         return result(reason === 'glm_request_timeout' ? 'timeout' : 'failed', controller.state().run_id, input.task, termination.reason, artifactDir, [], [response.error.code], []);
     }
     controller.transition('model_guard');
-    const modelGuard = assertGlm52ActualModel(response.value.model || GLM_52_OPENROUTER_MODEL);
+    const modelGuard = assertGlm52ActualModel(response.value.model);
     if (!modelGuard.ok) {
         const termination = controller.terminate('blocked', 'glm_model_mismatch', [modelGuard.code]);
         const artifactDir = await writeGlmRunArtifacts({ cwd: input.cwd, state: controller.state(), termination, contextOmissions: context.omitted });

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.9',
         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.9',
+            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.9',
+        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.9',
+        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