sneakoscope 4.0.9 → 4.0.11

package/dist/core/providers/glm/naruto/glm-naruto-isolation-policy.js

@@ -0,0 +1,38 @@
+export function resolveGlmNarutoIsolationPolicy(input) {
+    const requested = input.useWorktree ? 'git-worktree' : input.patchEnvelopeOnly ? 'patch-envelope-only' : 'auto';
+    if (input.patchEnvelopeOnly || !input.useWorktree) {
+        return {
+            schema: 'sks.glm-naruto-isolation-policy.v1',
+            requested,
+            selected: 'patch-envelope-only',
+            honest: true,
+            reason: input.patchEnvelopeOnly ? 'patch_envelope_only_requested' : 'worktree_not_requested',
+            blockers: [],
+            fallback_allowed: Boolean(input.fallbackAllowed),
+            workers_write_main_workspace: false
+        };
+    }
+    if (input.gitAvailable) {
+        return {
+            schema: 'sks.glm-naruto-isolation-policy.v1',
+            requested,
+            selected: 'git-worktree',
+            honest: true,
+            reason: 'git_worktree_available',
+            blockers: [],
+            fallback_allowed: Boolean(input.fallbackAllowed),
+            workers_write_main_workspace: false
+        };
+    }
+    return {
+        schema: 'sks.glm-naruto-isolation-policy.v1',
+        requested,
+        selected: input.fallbackAllowed ? 'patch-envelope-only' : 'blocked',
+        honest: true,
+        reason: input.fallbackAllowed ? 'git_worktree_unavailable_fallback_allowed' : 'git_worktree_unavailable',
+        blockers: input.fallbackAllowed ? [] : ['glm_naruto_worktree_not_implemented_or_unavailable'],
+        fallback_allowed: Boolean(input.fallbackAllowed),
+        workers_write_main_workspace: false
+    };
+}
+//# sourceMappingURL=glm-naruto-isolation-policy.js.map

package/dist/core/providers/glm/naruto/glm-naruto-merge-planner.js

@@ -1,12 +1,17 @@
 import { getNonConflictingSets } from './glm-naruto-conflict-graph.js';
 export function planMerge(input) {
-    const passedNodes = input.graph.nodes.filter((n) => n.gate_passed);
-    const nonConflictingSets = getNonConflictingSets(input.graph);
+    const scoreByPatch = new Map((input.scoreboard?.scores ?? []).map((score) => [score.patch_id, score]));
+    const passedNodes = input.graph.nodes.filter((n) => n.gate_passed && !scoreByPatch.get(n.patch_id)?.disqualified);
+    const filteredGraph = {
+        ...input.graph,
+        nodes: passedNodes
+    };
+    const nonConflictingSets = getNonConflictingSets(filteredGraph);
     const candidates = nonConflictingSets.map((patchIds) => {
         const nodes = passedNodes.filter((n) => patchIds.includes(n.patch_id));
-        const totalScore = nodes.reduce((sum, n) => sum + n.score, 0);
+        const totalScore = nodes.reduce((sum, n) => sum + (scoreByPatch.get(n.patch_id)?.total_score ?? n.score), 0);
         return { patch_ids: patchIds, total_score: totalScore, conflict_free: true };
-    });
+    }).filter((candidate) => candidate.patch_ids.every((id) => passedNodes.some((node) => node.patch_id === id)));
     candidates.sort((a, b) => b.total_score - a.total_score);
     let selected = [];
     let rationale = '';

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

@@ -0,0 +1,34 @@
+export function summarizeGlmNarutoWorkerMetrics(traces) {
+    const ttft = traces.map((trace) => trace.ttft_ms).filter(isNumber).sort((a, b) => a - b);
+    const totals = traces.map((trace) => trace.total_ms).filter(isNumber).sort((a, b) => a - b);
+    const verifier = traces.filter((trace) => trace.status === 'verification_passed' || trace.status === 'verification_failed');
+    const verifierPassed = verifier.filter((trace) => trace.status === 'verification_passed').length;
+    return {
+        p50_ttft_ms: percentile(ttft, 0.5),
+        p90_ttft_ms: percentile(ttft, 0.9),
+        p50_total_ms: percentile(totals, 0.5),
+        p90_total_ms: percentile(totals, 0.9),
+        cached_tokens_sum: sumNullable(traces.map((trace) => trace.cached_tokens ?? null)),
+        cache_write_tokens_sum: sumNullable(traces.map((trace) => trace.cache_write_tokens ?? null)),
+        reasoning_tokens_sum: sumNullable(traces.map((trace) => trace.reasoning_tokens ?? null)),
+        workers_completed: traces.filter((trace) => trace.status === 'completed').length,
+        workers_failed: traces.filter((trace) => trace.status === 'failed').length,
+        verifier_pass_rate: verifier.length ? verifierPassed / verifier.length : 0
+    };
+}
+function percentile(values, quantile) {
+    if (!values.length)
+        return null;
+    const index = Math.min(values.length - 1, Math.max(0, Math.ceil(values.length * quantile) - 1));
+    return values[index] ?? null;
+}
+function sumNullable(values) {
+    const present = values.filter(isNumber);
+    if (!present.length)
+        return null;
+    return present.reduce((sum, value) => sum + value, 0);
+}
+function isNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+//# sourceMappingURL=glm-naruto-metrics.js.map

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

@@ -2,20 +2,24 @@ import path from 'node:path';
 import { nowIso, writeJsonAtomic } from '../../../fsx.js';
 import { GLM_52_OPENROUTER_MODEL } from '../glm-52-settings.js';
 import { resolveOpenRouterApiKey } from '../../openrouter/openrouter-secret-store.js';
-import { checkAndApplyGlmPatch } from '../glm-patch-apply.js';
 import { decomposeTask, validateWorkGraph } from './glm-naruto-decomposer.js';
 import { planShardCandidates, computeInitialLaneMix } from './glm-naruto-shard-planner.js';
 import { runPatchWorkerPool } from './glm-naruto-worker-pool.js';
 import { runVerifierWorker } from './glm-naruto-worker-runtime.js';
 import { buildConflictGraph } from './glm-naruto-conflict-graph.js';
-import { planMerge } from './glm-naruto-merge-planner.js';
 import { finalizeMergePlan } from './glm-naruto-finalizer.js';
 import { planRepairWave } from './glm-naruto-repair-wave.js';
-import { createBudget, checkBudget, recordRequest } from './glm-naruto-budget.js';
+import { createBudget, checkBudget } from './glm-naruto-budget.js';
 import { createProviderHealthTracker } from '../../openrouter/openrouter-provider-health.js';
 import { createMissionTrace, recordWorkerTrace, writeMissionArtifacts, buildMissionSummary } from './glm-naruto-trace.js';
 import { runGlmJudge } from './glm-naruto-judge.js';
 import { writeFinalStopGate } from '../../../stop-gate/stop-gate-writer.js';
+import { auditGlmNarutoArtifactsForSecrets } from './glm-naruto-secret-audit.js';
+import { resolveGlmNarutoIsolationPolicy } from './glm-naruto-isolation-policy.js';
+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 { GLM_NARUTO_LIMITS } from './glm-naruto-types.js';
 export async function runGlmNarutoMission(input) {
     const missionId = input.missionId || `glm-naruto-${nowIso().replace(/[:.]/g, '-')}`;
@@ -23,10 +27,29 @@ export async function runGlmNarutoMission(input) {
     const startedMs = Date.now();
     const key = await resolveOpenRouterApiKey({ env: process.env });
     if (!key.key) {
-        return missionResult(missionId, input.task, 'blocked', 'glm_missing_openrouter_key', 0, startedMs, [], [], ['glm_missing_openrouter_key'], []);
+        return finalizeGlmNarutoTerminal({
+            root: cwd,
+            missionId,
+            result: missionResult(missionId, input.task, 'blocked', 'glm_missing_openrouter_key', 0, startedMs, [], [], ['glm_missing_openrouter_key'], [])
+        });
     }
     const mentionedPaths = extractMentionedPaths(input.task);
     const gitStatus = await readGitStatus(cwd);
+    const gitRoot = await getGitRoot(cwd);
+    const baseCommit = gitRoot ? await getGitHead(cwd) : null;
+    const isolationPolicy = resolveGlmNarutoIsolationPolicy({
+        ...(input.useWorktree !== undefined ? { useWorktree: input.useWorktree } : {}),
+        ...(input.patchEnvelopeOnly !== undefined ? { patchEnvelopeOnly: input.patchEnvelopeOnly } : {}),
+        ...(input.allowPatchEnvelopeFallback !== undefined ? { fallbackAllowed: input.allowPatchEnvelopeFallback } : {}),
+        gitAvailable: Boolean(gitRoot && baseCommit)
+    });
+    if (isolationPolicy.selected === 'blocked') {
+        return finalizeGlmNarutoTerminal({
+            root: cwd,
+            missionId,
+            result: missionResult(missionId, input.task, 'blocked', isolationPolicy.reason, 0, startedMs, [], [], isolationPolicy.blockers, [])
+        });
+    }
     const graph = decomposeTask({
         missionId,
         task: input.task,
@@ -36,12 +59,20 @@ export async function runGlmNarutoMission(input) {
     const isVerifyOnly = input.task.trim().toLowerCase().startsWith('verify');
     const validation = validateWorkGraph(graph, isVerifyOnly);
     if (!validation.ok) {
-        return missionResult(missionId, input.task, 'blocked', validation.reason || 'invalid_work_graph', 0, startedMs, [], [], [validation.reason || 'invalid_work_graph'], []);
+        return finalizeGlmNarutoTerminal({
+            root: cwd,
+            missionId,
+            result: missionResult(missionId, input.task, 'blocked', validation.reason || 'invalid_work_graph', 0, startedMs, [], [], [validation.reason || 'invalid_work_graph'], [])
+        });
     }
     const budget = createBudget(missionId, input.deep || false);
     const budgetCheck = checkBudget(budget);
     if (!budgetCheck.ok) {
-        return missionResult(missionId, input.task, 'budget_exhausted', budgetCheck.reason, 0, startedMs, [], [], [budgetCheck.reason], []);
+        return finalizeGlmNarutoTerminal({
+            root: cwd,
+            missionId,
+            result: missionResult(missionId, input.task, 'budget_exhausted', budgetCheck.reason, 0, startedMs, [], [], [budgetCheck.reason], [])
+        });
     }
     const laneMix = computeInitialLaneMix(graph);
     const strategies = planShardCandidates(graph);
@@ -60,10 +91,22 @@ export async function runGlmNarutoMission(input) {
         contextSummary: JSON.stringify({ task: input.task, git_status: gitStatus || '' }),
         maxWorkers: input.maxWorkers || laneMix.patch_workers,
         workerTimeoutMs: GLM_NARUTO_LIMITS.max_worker_runtime_ms,
-        strategies: strategyMap
+        strategies: strategyMap,
+        isolationMode: isolationPolicy.selected,
+        cleanupWorktrees: input.cleanupWorktrees ?? !input.keepWorktrees,
+        baseCommit
     });
     for (const trace of poolResult.traces) {
         traceState = recordWorkerTrace(traceState, trace);
+        if (trace.ttft_ms !== null) {
+            healthTracker.record({
+                provider_slug: trace.provider_slug || 'openrouter',
+                model: trace.model,
+                p50_ttft_ms: trace.ttft_ms,
+                last_success: trace.status === 'completed' || trace.status === 'verification_passed' ? nowIso() : null,
+                last_failure: trace.status === 'failed' ? nowIso() : null
+            });
+        }
     }
     healthTracker.record({ provider_slug: 'openrouter', model: GLM_52_OPENROUTER_MODEL, count_429: 0, count_5xx: 0 });
     let envelopes = poolResult.envelopes;
@@ -86,7 +129,10 @@ export async function runGlmNarutoMission(input) {
                 contextSummary: JSON.stringify({ task: input.task, repair: true }),
                 maxWorkers: input.maxWorkers || 3,
                 workerTimeoutMs: GLM_NARUTO_LIMITS.max_worker_runtime_ms,
-                strategies: new Map(repairPlan.shardsToRepair.map((s) => [s.id, [s.strategy]]))
+                strategies: new Map(repairPlan.shardsToRepair.map((s) => [s.id, [s.strategy]])),
+                isolationMode: isolationPolicy.selected,
+                cleanupWorktrees: input.cleanupWorktrees ?? !input.keepWorktrees,
+                baseCommit
             });
             envelopes = [...envelopes, ...repairPool.envelopes];
             for (const trace of repairPool.traces) {
@@ -97,7 +143,9 @@ export async function runGlmNarutoMission(input) {
     }
     // 4.0.9: Verifier wave — run parallel verifier workers over gate-passed candidates.
     let passedEnvelopes = envelopes.filter((e) => e.status === 'gate_passed');
-    if (passedEnvelopes.length > 0 && !input.noApply) {
+    let verifierWaveRun = false;
+    if (passedEnvelopes.length > 0 && !input.skipVerifier) {
+        verifierWaveRun = true;
         const verifyApiKey = key.key;
         const verifyResults = await Promise.allSettled(passedEnvelopes.map((env) => runVerifierWorker({
             apiKey: verifyApiKey,
@@ -118,6 +166,15 @@ export async function runGlmNarutoMission(input) {
             }
             if (res.status === 'fulfilled') {
                 traceState = recordWorkerTrace(traceState, res.value.trace);
+                if (res.value.trace.ttft_ms !== null) {
+                    healthTracker.record({
+                        provider_slug: res.value.trace.provider_slug || 'openrouter',
+                        model: res.value.trace.model,
+                        p50_ttft_ms: res.value.trace.ttft_ms,
+                        last_success: res.value.ok ? nowIso() : null,
+                        last_failure: res.value.ok ? null : nowIso()
+                    });
+                }
             }
         }
         envelopes = envelopes.map((e) => {
@@ -126,6 +183,7 @@ export async function runGlmNarutoMission(input) {
         });
         passedEnvelopes = envelopes.filter((e) => e.status === 'gate_passed');
     }
+    const warnings = input.skipVerifier && passedEnvelopes.length > 0 ? ['verifier_skipped_by_flag'] : [];
     // Build conflict graph and merge plan
     const nodes = passedEnvelopes.map((env) => ({
         patch_id: env.worker_id,
@@ -136,6 +194,13 @@ export async function runGlmNarutoMission(input) {
         patch_sha256: env.patch_sha256
     }));
     const conflictGraph = buildConflictGraph(passedEnvelopes, nodes);
+    const candidateScoreboard = buildGlmNarutoCandidateScoreboard({
+        missionId,
+        envelopes,
+        traces: traceState.workerTraces,
+        graph: conflictGraph,
+        requestedPaths: mentionedPaths
+    });
     let judgeResult = null;
     if (input.useJudge && passedEnvelopes.length > 1) {
         judgeResult = await runGlmJudge({
@@ -149,26 +214,33 @@ export async function runGlmNarutoMission(input) {
         missionId,
         envelopes: passedEnvelopes,
         ...(judgeResult ? { judgeResult } : {}),
+        scoreboard: candidateScoreboard,
         useJudge: input.useJudge || false,
         xhighFinalizer: input.xhighFinalizer || false
     });
     // Apply winning merge plan
     let appliedPatches = 0;
     let applyResult = null;
+    let applyTransaction = null;
+    const artifactDir = path.join(cwd, '.sneakoscope', 'glm-naruto', missionId);
     if (!input.noApply && mergePlan.selected_patches.length > 0) {
-        for (const patchId of mergePlan.selected_patches) {
-            const envelope = envelopes.find((e) => e.worker_id === patchId);
-            if (!envelope)
-                continue;
-            const applied = await checkAndApplyGlmPatch({ cwd, patch: envelope.patch, apply: true });
-            if (applied.ok) {
-                appliedPatches++;
-            }
-        }
-        applyResult = { ok: appliedPatches > 0, applied: mergePlan.selected_patches };
+        const transactionResult = await runGlmNarutoApplyTransaction({
+            cwd,
+            missionId,
+            envelopes,
+            selectedPatchIds: mergePlan.selected_patches,
+            artifactDir
+        });
+        applyTransaction = transactionResult.transaction;
+        appliedPatches = transactionResult.ok ? transactionResult.applied.length : 0;
+        applyResult = { ok: transactionResult.ok, applied: transactionResult.applied, ...(transactionResult.transaction.blockers[0] ? { blocker: transactionResult.transaction.blockers[0] } : {}) };
     }
     const terminalState = appliedPatches > 0 ? 'completed' : passedEnvelopes.length > 0 ? 'partial_candidates' : 'blocked';
-    const terminationReason = appliedPatches > 0 ? 'completed_merge_applied' : passedEnvelopes.length > 0 ? 'partial_no_apply' : 'no_gate_passed_candidates';
+    const terminationReason = appliedPatches > 0
+        ? 'completed_merge_applied'
+        : applyResult && !applyResult.ok
+            ? 'apply_transaction_failed'
+            : passedEnvelopes.length > 0 ? 'partial_no_apply' : 'no_gate_passed_candidates';
     const summary = buildMissionSummary({
         missionId,
         startedMs,
@@ -198,10 +270,10 @@ export async function runGlmNarutoMission(input) {
         failed_shards: summary.failed_shards,
         repair_waves: summary.repair_waves,
         budget_used_ms: summary.budget_used_ms,
-        blockers: terminalState === 'blocked' ? ['no_gate_passed_candidates'] : [],
-        warnings: []
+        blockers: terminalState === 'blocked' ? ['no_gate_passed_candidates'] : (applyResult && !applyResult.ok ? [applyResult.blocker || 'apply_transaction_failed'] : []),
+        warnings
     };
-    const artifactDir = await writeMissionArtifacts({
+    const writtenArtifactDir = await writeMissionArtifacts({
         root: cwd,
         missionId,
         workGraph: graph,
@@ -210,19 +282,31 @@ export async function runGlmNarutoMission(input) {
         ...(judgeResult ? { judgeResult } : {}),
         workerTraces: traceState.workerTraces,
         providerHealth: healthTracker.snapshot(),
+        concurrencyDecisions: poolResult.concurrencyDecisions,
+        isolationPolicy,
+        candidateScoreboard,
         termination: { schema: 'sks.glm-naruto-termination.v1', mission_id: missionId, terminal_state: terminalState, reason: terminationReason, wall_clock_ms: summary.wall_clock_ms },
         ...(applyResult ? { applyResult: { ...applyResult, schema: 'sks.glm-naruto-apply-result.v1' } } : {}),
-        verificationSummary: { schema: 'sks.glm-naruto-verification.v1', verified: passedEnvelopes.length, total: envelopes.length },
+        ...(applyTransaction ? { applyTransaction } : {}),
+        verificationSummary: { schema: 'sks.glm-naruto-verification.v1', verified: passedEnvelopes.length, total: envelopes.length, verifier_wave_run: verifierWaveRun, skip_verifier: input.skipVerifier === true },
         missionResult: result,
         envelopes
     });
+    const secretAudit = await auditGlmNarutoArtifactsForSecrets(path.join(cwd, '.sneakoscope', 'glm-naruto', missionId)).catch((err) => ({
+        schema: 'sks.glm-naruto-secret-audit.v1',
+        ok: false,
+        root: path.join(cwd, '.sneakoscope', 'glm-naruto', missionId),
+        scanned_files: 0,
+        findings: [`audit_failed:${err instanceof Error ? err.message : String(err)}`]
+    }));
+    await writeJsonAtomic(path.join(writtenArtifactDir, 'secret-audit.json'), secretAudit).catch(() => undefined);
     // 4.0.9: Write canonical stop-gate artifacts for hook resolution.
     await writeFinalStopGate({
         root: cwd,
         missionId,
         route: 'GLM_NARUTO',
         routeCommand: '$Naruto',
-        status: result.ok ? 'passed' : (terminalState === 'blocked' ? 'blocked' : 'failed'),
+        status: result.ok && secretAudit.ok ? 'passed' : (terminalState === 'blocked' || !secretAudit.ok ? 'blocked' : 'failed'),
         terminal: terminalState === 'completed' || terminalState === 'blocked',
         terminalState,
         evidence: {
@@ -230,13 +314,17 @@ export async function runGlmNarutoMission(input) {
             tests_passed: result.ok,
             route_evidence_passed: result.ok,
             per_worker_artifacts: true,
-            verifier_wave_run: true,
+            verifier_wave_run: verifierWaveRun,
             model_guard_enforced: true,
+            proof_required: false,
+            proof_passed: true,
+            reflection_required: false,
+            reflection_passed: 'not_required',
         },
-        blockers: result.blockers || [],
+        blockers: secretAudit.ok ? (result.blockers || []) : ['glm_naruto_secret_leak_detected'],
         nativeGateFile: 'termination.json',
     }).catch(() => null);
-    return { ...result, artifact_dir: artifactDir };
+    return { ...result, artifact_dir: writtenArtifactDir };
 }
 function missionResult(missionId, task, status, reason, patchCandidates, startedMs, envelopes, traces, blockers, warnings) {
     return {

package/dist/core/providers/glm/naruto/glm-naruto-patch-candidate-gate.js

@@ -0,0 +1,42 @@
+import { checkAndApplyGlmPatch } from '../glm-patch-apply.js';
+import { parseGlmNarutoPatchCandidate } from './glm-naruto-patch-candidate-parser.js';
+const PROTECTED_PATH = /(^|\/)(\.github|dist|node_modules)(\/|$)/;
+const SECRET_PATTERN = /\b(?:Bearer\s+[A-Za-z0-9._~+/-]+|sk-(?:or-)?[A-Za-z0-9_-]{12,}|OPENROUTER_API_KEY|SKS_OPENROUTER_API_KEY)\b/;
+export async function evaluateGlmNarutoPatchCandidateGate(input) {
+    const checks = [];
+    const parsed = parseGlmNarutoPatchCandidate(input.envelope.patch);
+    checks.push(check('candidate_parse', parsed.ok, parsed.blockers.join(',') || undefined));
+    checks.push(check('patch_section', Boolean(parsed.patch), parsed.patch ? undefined : 'missing_patch_section'));
+    checks.push(check('unified_diff', /^diff --git /m.test(parsed.patch), parsed.patch ? undefined : 'no_diff_git'));
+    const blockedPath = parsed.touched_paths.find((file) => PROTECTED_PATH.test(file));
+    checks.push(check('protected_path_guard', !blockedPath, blockedPath));
+    const secretLeak = SECRET_PATTERN.test(parsed.patch);
+    checks.push(check('secret_leakage_guard', !secretLeak, secretLeak ? 'secret_like_content' : undefined));
+    if (parsed.ok && !blockedPath && !secretLeak) {
+        const applyCheck = await checkAndApplyGlmPatch({
+            cwd: input.cwd,
+            patch: parsed.patch,
+            apply: input.apply === true
+        });
+        checks.push(check('git_apply_check', applyCheck.ok, applyCheck.ok ? undefined : applyCheck.error.code));
+    }
+    else {
+        checks.push({ id: 'git_apply_check', ok: false, reason: 'skipped_due_to_prior_blocker', ms: 0 });
+    }
+    const blockers = checks.filter((row) => !row.ok).map((row) => row.reason || row.id);
+    return {
+        schema: 'sks.glm-naruto-patch-candidate-gate.v1',
+        ok: blockers.length === 0,
+        worker_id: input.envelope.worker_id,
+        shard_id: input.envelope.shard_id,
+        patch_id: input.envelope.patch_sha256,
+        extracted_patch: parsed.patch,
+        touched_paths: parsed.touched_paths,
+        checks,
+        blockers
+    };
+}
+function check(id, ok, reason) {
+    return { id, ok, ...(reason ? { reason } : {}), ms: 0 };
+}
+//# sourceMappingURL=glm-naruto-patch-candidate-gate.js.map

package/dist/core/providers/glm/naruto/glm-naruto-patch-candidate-parser.js

@@ -0,0 +1,62 @@
+import { parseUnifiedDiffPatch } from '../glm-patch-parser.js';
+const CANDIDATE_OPEN = '<sks_patch_candidate>';
+const CANDIDATE_CLOSE = '</sks_patch_candidate>';
+const LEGACY_PATCH_OPEN = '<sks_patch>';
+export function parseGlmNarutoPatchCandidate(text) {
+    const blockers = [];
+    if (text.includes(LEGACY_PATCH_OPEN) && !text.includes(CANDIDATE_OPEN)) {
+        return failed(text, ['legacy_sks_patch_envelope_rejected']);
+    }
+    const body = unwrapCandidateBody(text);
+    if (!body.ok)
+        return failed(text, body.blockers);
+    const extracted = extractPatchSection(body.body);
+    if (!extracted.ok)
+        return failed(body.body, extracted.blockers);
+    const parsed = parseUnifiedDiffPatch(extracted.patch);
+    if (parsed.empty)
+        blockers.push('patch_missing_unified_diff');
+    return {
+        ok: blockers.length === 0,
+        body: body.body,
+        patch: extracted.patch,
+        touched_paths: parsed.touchedPaths,
+        blockers
+    };
+}
+function unwrapCandidateBody(text) {
+    const start = text.indexOf(CANDIDATE_OPEN);
+    const end = text.indexOf(CANDIDATE_CLOSE);
+    if (start >= 0 || end >= 0) {
+        if (start < 0 || end <= start)
+            return { ok: false, blockers: ['malformed_patch_candidate_envelope'] };
+        return { ok: true, body: text.slice(start + CANDIDATE_OPEN.length, end).trim() };
+    }
+    if (/^\s*patch\s*:/im.test(text))
+        return { ok: true, body: text.trim() };
+    return { ok: false, blockers: ['missing_patch_candidate_envelope'] };
+}
+function extractPatchSection(body) {
+    const lines = body.split(/\r?\n/);
+    const patchLine = lines.findIndex((line) => /^\s*patch\s*:/i.test(line));
+    if (patchLine < 0)
+        return { ok: false, blockers: ['missing_patch_section'] };
+    const firstLine = lines[patchLine] || '';
+    const inline = firstLine.replace(/^\s*patch\s*:\s*/i, '');
+    const tail = inline.trim() ? [inline, ...lines.slice(patchLine + 1)] : lines.slice(patchLine + 1);
+    const raw = tail.join('\n').replace(/^\s*```(?:diff|patch)?\s*/i, '').replace(/\s*```\s*$/i, '').trim();
+    const diffIndex = raw.search(/^diff --git /m);
+    if (diffIndex < 0)
+        return { ok: false, blockers: ['patch_missing_diff_git'] };
+    return { ok: true, patch: raw.slice(diffIndex).trimEnd() + '\n' };
+}
+function failed(body, blockers) {
+    return {
+        ok: false,
+        body,
+        patch: '',
+        touched_paths: [],
+        blockers
+    };
+}
+//# sourceMappingURL=glm-naruto-patch-candidate-parser.js.map

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

@@ -0,0 +1,75 @@
+const SECRET_PATTERN = /\b(?:Bearer\s+[A-Za-z0-9._~+/-]+|sk-(?:or-)?[A-Za-z0-9_-]{12,}|OPENROUTER_API_KEY|SKS_OPENROUTER_API_KEY)\b/;
+export function buildGlmNarutoCandidateScoreboard(input) {
+    const strategyCounts = new Map();
+    for (const envelope of input.envelopes) {
+        const set = strategyCounts.get(envelope.shard_id) ?? new Set();
+        set.add(envelope.strategy);
+        strategyCounts.set(envelope.shard_id, set);
+    }
+    return {
+        schema: 'sks.glm-naruto-candidate-scoreboard.v1',
+        mission_id: input.missionId,
+        scores: input.envelopes.map((envelope) => {
+            const trace = input.traces.find((item) => item.worker_id === envelope.worker_id || item.patch_digest === envelope.patch_sha256);
+            return scoreEnvelope({
+                envelope,
+                ...(trace ? { trace } : {}),
+                graph: input.graph,
+                requestedPaths: input.requestedPaths,
+                strategyDiversity: strategyCounts.get(envelope.shard_id)?.size ?? 1
+            });
+        })
+    };
+}
+function scoreEnvelope(input) {
+    const disqualification_reasons = [];
+    const secretLeak = SECRET_PATTERN.test(input.envelope.patch) || input.envelope.blockers.includes('secret_like_content');
+    const verifierFailed = input.envelope.status === 'verification_failed' || input.envelope.verification_passed === false;
+    const gatePassed = input.envelope.status === 'gate_passed' || input.envelope.status === 'selected' || input.envelope.verification_passed === true;
+    if (!gatePassed)
+        disqualification_reasons.push('deterministic_gate_failed');
+    if (verifierFailed)
+        disqualification_reasons.push('verifier_failed');
+    if (secretLeak)
+        disqualification_reasons.push('secret_leak');
+    if (input.envelope.blockers.some((blocker) => blocker.includes('protected')))
+        disqualification_reasons.push('protected_path');
+    const conflictCount = input.graph.edges.filter((edge) => edge.left_patch_id === input.envelope.worker_id || edge.right_patch_id === input.envelope.worker_id).length;
+    const requested = new Set(input.requestedPaths);
+    const targetAligned = requested.size === 0 || input.envelope.target_paths.some((target) => requested.has(target));
+    const risk = clamp(input.trace?.verifier_risk_score ?? (verifierFailed ? 1 : 0));
+    const confidence = clamp(input.trace?.verifier_confidence ?? (input.envelope.verification_passed ? 1 : 0));
+    const latency = input.trace?.ttft_ms ?? input.trace?.total_ms ?? 0;
+    const cacheTokens = input.trace?.cached_tokens ?? 0;
+    const patchSizePenalty = Math.min(50, Math.ceil(input.envelope.patch.length / 400));
+    const components = {
+        deterministic_gate: gatePassed ? 100 : 0,
+        verifier: input.envelope.verification_passed === false ? -100 : input.envelope.verification_passed === true ? 50 : 0,
+        verifier_confidence: Math.round(confidence * 20),
+        verifier_risk_penalty: -Math.round(risk * 50),
+        patch_size_penalty: -patchSizePenalty,
+        touched_path_penalty: -Math.min(30, input.envelope.target_paths.length * 5),
+        target_alignment: targetAligned ? 20 : -30,
+        hunk_conflict_penalty: -Math.min(60, conflictCount * 20),
+        latency_penalty: -Math.min(25, Math.floor(latency / 2_000)),
+        cache_bonus: Math.min(20, Math.floor(cacheTokens / 1_000)),
+        strategy_diversity_bonus: input.strategyDiversity > 1 ? 10 : 0,
+        secret_safety: secretLeak ? -1_000 : 25
+    };
+    const total = Object.values(components).reduce((sum, value) => sum + value, 0);
+    return {
+        schema: 'sks.glm-naruto-candidate-score.v1',
+        patch_id: input.envelope.worker_id,
+        shard_id: input.envelope.shard_id,
+        total_score: disqualification_reasons.length ? -1_000 : total,
+        components,
+        disqualified: disqualification_reasons.length > 0,
+        disqualification_reasons
+    };
+}
+function clamp(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.min(1, value));
+}
+//# sourceMappingURL=glm-naruto-scoreboard.js.map

package/dist/core/providers/glm/naruto/glm-naruto-secret-audit.js

@@ -0,0 +1,91 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+const SECRET_PATTERN = /\b(?:Bearer\s+[A-Za-z0-9._~+/-]+|sk-(?:or-)?[A-Za-z0-9_-]{12,}|OPENROUTER_API_KEY|SKS_OPENROUTER_API_KEY)\b/;
+const SECRET_KEY_PATTERN = /^(authorization|api_key|apiKey|access_token|token|secret|password|OPENROUTER_API_KEY|SKS_OPENROUTER_API_KEY)$/i;
+const REDACTED_MARKERS = new Set(['[REDACTED]', '<redacted>', 'sk-or-[REDACTED]', 'Bearer [REDACTED]']);
+export async function auditGlmNarutoArtifactsForSecrets(root) {
+    const findings = [];
+    let scanned = 0;
+    await scan(root, async (file) => {
+        if (!/\.(json|jsonl|md|txt)$/i.test(file))
+            return;
+        scanned++;
+        const content = await fsp.readFile(file, 'utf8').catch(() => '');
+        const fileFindings = auditContentForSecrets(content);
+        if (fileFindings.length)
+            findings.push(`${path.relative(root, file)}:${fileFindings.join(',')}`);
+    });
+    return {
+        schema: 'sks.glm-naruto-secret-audit.v1',
+        ok: findings.length === 0,
+        root,
+        scanned_files: scanned,
+        findings
+    };
+}
+export function auditContentForSecrets(content) {
+    const findings = [];
+    if (SECRET_PATTERN.test(content))
+        findings.push('secret_like_content');
+    for (const parsed of parseJsonLike(content)) {
+        collectJsonSecretFindings(parsed, findings);
+    }
+    return [...new Set(findings)];
+}
+function parseJsonLike(content) {
+    const parsed = [];
+    try {
+        parsed.push(JSON.parse(content));
+        return parsed;
+    }
+    catch { }
+    for (const line of content.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('{') && !trimmed.startsWith('['))
+            continue;
+        try {
+            parsed.push(JSON.parse(trimmed));
+        }
+        catch { }
+    }
+    return parsed;
+}
+function collectJsonSecretFindings(value, findings, key = '') {
+    if (!value || typeof value !== 'object') {
+        if (SECRET_KEY_PATTERN.test(key) && typeof value === 'string' && value.trim() && !REDACTED_MARKERS.has(value.trim())) {
+            findings.push(`secret_key:${key}`);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectJsonSecretFindings(item, findings, key);
+        return;
+    }
+    for (const [entryKey, entryValue] of Object.entries(value)) {
+        if (SECRET_KEY_PATTERN.test(entryKey)) {
+            if (typeof entryValue === 'string' && entryValue.trim() && !REDACTED_MARKERS.has(entryValue.trim()))
+                findings.push(`secret_key:${entryKey}`);
+            else if (entryValue && typeof entryValue === 'object')
+                findings.push(`secret_key:${entryKey}`);
+        }
+        collectJsonSecretFindings(entryValue, findings, entryKey);
+    }
+}
+async function scan(dir, visit) {
+    let entries;
+    try {
+        entries = await fsp.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const p = path.join(dir, String(entry.name));
+        if (entry.isDirectory())
+            await scan(p, visit);
+        else if (entry.isFile())
+            await visit(p);
+    }
+}
+//# sourceMappingURL=glm-naruto-secret-audit.js.map

package/dist/core/providers/glm/naruto/glm-naruto-session-id.js

@@ -0,0 +1,10 @@
+import crypto from 'node:crypto';
+const SAFE_SESSION_ID = /^[A-Za-z0-9._:-]+$/;
+export function normalizeGlmNarutoSessionId(raw) {
+    const sanitized = raw.replace(/[^A-Za-z0-9._:-]/g, '-');
+    if (sanitized.length <= 256 && SAFE_SESSION_ID.test(sanitized))
+        return sanitized;
+    const digest = crypto.createHash('sha256').update(sanitized).digest('hex').slice(0, 24);
+    return `${sanitized.slice(0, 231)}-${digest}`.slice(0, 256);
+}
+//# sourceMappingURL=glm-naruto-session-id.js.map