sneakoscope 4.0.7 → 4.0.9

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

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

@@ -0,0 +1,84 @@
+import { buildGlm52Request } from '../glm-52-request.js';
+import { sendOpenRouterChatCompletionStream } from '../../openrouter/openrouter-stream.js';
+import { assertGlm52ActualModel } from '../glm-52-response-guard.js';
+import { GLM_52_OPENROUTER_MODEL } from '../glm-52-settings.js';
+export async function runGlmJudge(input) {
+    const validEnvelopes = input.envelopes.filter((e) => e.status === 'gate_passed');
+    if (validEnvelopes.length === 0) {
+        return {
+            schema: 'sks.glm-naruto-judge.v1',
+            ranked_patch_ids: [],
+            reject_patch_ids: [],
+            mergeable_sets: [],
+            risks: ['no_gate_passed_candidates'],
+            requires_repair_wave: false
+        };
+    }
+    const systemPrompt = `You are a GLM Naruto judge. Rank patch candidates by quality. Output strict JSON with schema: {"ranked_patch_ids":["id1","id2"],"reject_patch_ids":["id3"],"mergeable_sets":[["id1","id2"]],"risks":[],"requires_repair_wave":false}. Model: ${GLM_52_OPENROUTER_MODEL}. No GPT fallback.`;
+    const candidateDescriptions = validEnvelopes.map((e) => ({
+        patch_id: e.worker_id,
+        shard_id: e.shard_id,
+        target_paths: e.target_paths,
+        patch_sha256: e.patch_sha256.slice(0, 12),
+        strategy: e.strategy,
+        patch_size: e.patch.length
+    }));
+    const userContent = JSON.stringify({
+        mission_id: input.missionId,
+        candidates: candidateDescriptions,
+        instruction: 'Rank by: gate pass, minimal diff, correct target paths, no protected paths. Return mergeable non-conflicting sets.'
+    });
+    const messages = [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: userContent }
+    ];
+    const request = buildGlm52Request({
+        profile: 'deep',
+        messages,
+        maxTokens: 8192,
+        reasoningEffort: 'high',
+        toolChoice: 'none',
+        parallelToolCalls: false
+    });
+    const response = await sendOpenRouterChatCompletionStream({
+        apiKey: input.apiKey,
+        request: { ...request, session_id: `sks-glm-naruto-judge-${input.missionId}` },
+        timeoutMs: input.timeoutMs || 120_000
+    });
+    if (!response.ok) {
+        return fallbackJudgeResult(validEnvelopes, [`judge_request_failed:${response.error.code}`]);
+    }
+    const modelGuard = assertGlm52ActualModel(response.value.model);
+    if (!modelGuard.ok) {
+        return fallbackJudgeResult(validEnvelopes, [`judge_model_guard:${modelGuard.code}`]);
+    }
+    try {
+        const jsonMatch = response.value.content.match(/\{[\s\S]*\}/);
+        if (!jsonMatch)
+            return fallbackJudgeResult(validEnvelopes, ['judge_no_json_output']);
+        const parsed = JSON.parse(jsonMatch[0]);
+        return {
+            schema: 'sks.glm-naruto-judge.v1',
+            ranked_patch_ids: Array.isArray(parsed.ranked_patch_ids) ? parsed.ranked_patch_ids : [],
+            reject_patch_ids: Array.isArray(parsed.reject_patch_ids) ? parsed.reject_patch_ids : [],
+            mergeable_sets: Array.isArray(parsed.mergeable_sets) ? parsed.mergeable_sets : [],
+            risks: Array.isArray(parsed.risks) ? parsed.risks : [],
+            requires_repair_wave: Boolean(parsed.requires_repair_wave)
+        };
+    }
+    catch {
+        return fallbackJudgeResult(validEnvelopes, ['judge_json_parse_failed']);
+    }
+}
+function fallbackJudgeResult(envelopes, risks) {
+    const sorted = [...envelopes].sort((a, b) => a.patch.length - b.patch.length);
+    return {
+        schema: 'sks.glm-naruto-judge.v1',
+        ranked_patch_ids: sorted.map((e) => e.worker_id),
+        reject_patch_ids: [],
+        mergeable_sets: sorted.length > 0 ? [[sorted[0].worker_id]] : [],
+        risks,
+        requires_repair_wave: false
+    };
+}
+//# sourceMappingURL=glm-naruto-judge.js.map

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

@@ -0,0 +1,57 @@
+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 candidates = nonConflictingSets.map((patchIds) => {
+        const nodes = passedNodes.filter((n) => patchIds.includes(n.patch_id));
+        const totalScore = nodes.reduce((sum, n) => sum + n.score, 0);
+        return { patch_ids: patchIds, total_score: totalScore, conflict_free: true };
+    });
+    candidates.sort((a, b) => b.total_score - a.total_score);
+    let selected = [];
+    let rationale = '';
+    if (input.strategy === 'judge' && input.judgeRanking && input.judgeRanking.length > 0) {
+        const ranked = input.judgeRanking.filter((id) => passedNodes.some((n) => n.patch_id === id));
+        const bestSet = candidates.find((set) => set.patch_ids.every((id) => ranked.includes(id))) || candidates[0];
+        selected = bestSet ? bestSet.patch_ids : [];
+        rationale = 'judge_ranked_deterministic_gated';
+    }
+    else if (input.strategy === 'quorum') {
+        const quorumMap = new Map();
+        for (const node of passedNodes) {
+            const key = node.shard_id;
+            quorumMap.set(key, (quorumMap.get(key) || 0) + 1);
+        }
+        const bestSet = candidates[0];
+        selected = bestSet ? bestSet.patch_ids : [];
+        rationale = 'quorum_consensus_deterministic_gated';
+    }
+    else {
+        const bestSet = candidates[0];
+        selected = bestSet ? bestSet.patch_ids : [];
+        rationale = 'highest_score_non_conflicting';
+    }
+    return {
+        schema: 'sks.glm-naruto-merge-plan.v1',
+        mission_id: input.missionId,
+        strategy: input.strategy,
+        selected_patches: selected,
+        candidates,
+        rationale
+    };
+}
+export function scoreCandidate(input) {
+    let score = 0;
+    if (input.node.gate_passed)
+        score += 100;
+    score -= input.patchSize / 100;
+    score -= input.touchedPathsCount * 5;
+    if (input.protectedPath)
+        score -= 200;
+    if (input.testFailure)
+        score -= 50;
+    if (input.judgeRank !== null && input.judgeRank !== undefined)
+        score += Math.max(0, 50 - input.judgeRank * 10);
+    return Math.round(score);
+}
+//# sourceMappingURL=glm-naruto-merge-planner.js.map

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

@@ -0,0 +1,277 @@
+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 { 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 { GLM_NARUTO_LIMITS } from './glm-naruto-types.js';
+export async function runGlmNarutoMission(input) {
+    const missionId = input.missionId || `glm-naruto-${nowIso().replace(/[:.]/g, '-')}`;
+    const cwd = input.cwd;
+    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'], []);
+    }
+    const mentionedPaths = extractMentionedPaths(input.task);
+    const gitStatus = await readGitStatus(cwd);
+    const graph = decomposeTask({
+        missionId,
+        task: input.task,
+        gitStatus,
+        mentionedPaths
+    });
+    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'], []);
+    }
+    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], []);
+    }
+    const laneMix = computeInitialLaneMix(graph);
+    const strategies = planShardCandidates(graph);
+    const strategyMap = new Map();
+    for (const entry of strategies) {
+        strategyMap.set(entry.shard.id, entry.strategies);
+    }
+    const healthTracker = createProviderHealthTracker();
+    let traceState = createMissionTrace(missionId);
+    // Wave 1: parallel patch candidate generation
+    const poolResult = await runPatchWorkerPool({
+        apiKey: key.key,
+        missionId,
+        cwd,
+        shards: graph.shards,
+        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
+    });
+    for (const trace of poolResult.traces) {
+        traceState = recordWorkerTrace(traceState, trace);
+    }
+    healthTracker.record({ provider_slug: 'openrouter', model: GLM_52_OPENROUTER_MODEL, count_429: 0, count_5xx: 0 });
+    let envelopes = poolResult.envelopes;
+    let failedShardIds = poolResult.failedShardIds;
+    let repairWaves = 0;
+    // Repair wave if needed
+    if (failedShardIds.length > 0 && repairWaves < GLM_NARUTO_LIMITS.max_repair_waves) {
+        const repairPlan = planRepairWave({
+            failedEnvelopes: envelopes.filter((e) => e.status === 'gate_failed'),
+            shards: graph.shards,
+            repairWaveCount: repairWaves
+        });
+        if (repairPlan.canRepair && repairPlan.shardsToRepair.length > 0) {
+            repairWaves++;
+            const repairPool = await runPatchWorkerPool({
+                apiKey: key.key,
+                missionId,
+                cwd,
+                shards: repairPlan.shardsToRepair,
+                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]]))
+            });
+            envelopes = [...envelopes, ...repairPool.envelopes];
+            for (const trace of repairPool.traces) {
+                traceState = recordWorkerTrace(traceState, trace);
+            }
+            failedShardIds = [...failedShardIds, ...repairPool.failedShardIds];
+        }
+    }
+    // 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) {
+        const verifyApiKey = key.key;
+        const verifyResults = await Promise.allSettled(passedEnvelopes.map((env) => runVerifierWorker({
+            apiKey: verifyApiKey,
+            missionId,
+            workerId: env.worker_id,
+            envelope: env,
+            timeoutMs: 120_000,
+        })));
+        const verifiedEnvelopes = [];
+        for (let vi = 0; vi < passedEnvelopes.length; vi++) {
+            const env = passedEnvelopes[vi];
+            const res = verifyResults[vi];
+            if (res.status === 'fulfilled' && res.value.ok) {
+                verifiedEnvelopes.push({ ...env, verification_passed: true, status: 'gate_passed' });
+            }
+            else {
+                verifiedEnvelopes.push({ ...env, verification_passed: false, status: 'verification_failed' });
+            }
+            if (res.status === 'fulfilled') {
+                traceState = recordWorkerTrace(traceState, res.value.trace);
+            }
+        }
+        envelopes = envelopes.map((e) => {
+            const verified = verifiedEnvelopes.find((v) => v.worker_id === e.worker_id);
+            return verified ?? e;
+        });
+        passedEnvelopes = envelopes.filter((e) => e.status === 'gate_passed');
+    }
+    // Build conflict graph and merge plan
+    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);
+    let judgeResult = null;
+    if (input.useJudge && passedEnvelopes.length > 1) {
+        judgeResult = await runGlmJudge({
+            apiKey: key.key,
+            missionId,
+            envelopes: passedEnvelopes,
+            timeoutMs: 120_000
+        });
+    }
+    const mergePlan = finalizeMergePlan({
+        missionId,
+        envelopes: passedEnvelopes,
+        ...(judgeResult ? { judgeResult } : {}),
+        useJudge: input.useJudge || false,
+        xhighFinalizer: input.xhighFinalizer || false
+    });
+    // Apply winning merge plan
+    let appliedPatches = 0;
+    let applyResult = null;
+    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 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 summary = buildMissionSummary({
+        missionId,
+        startedMs,
+        workerTraces: traceState.workerTraces,
+        patchCandidates: envelopes.length,
+        gatePassed: passedEnvelopes.length,
+        mergeable: mergePlan.candidates.length,
+        appliedPatches,
+        failedShards: failedShardIds.length,
+        repairWaves
+    });
+    const result = {
+        schema: 'sks.glm-naruto-mission-result.v1',
+        ok: terminalState === 'completed',
+        status: terminalState,
+        mission_id: missionId,
+        task: input.task,
+        model: GLM_52_OPENROUTER_MODEL,
+        gpt_fallback_allowed: false,
+        termination_reason: terminationReason,
+        workers_started: summary.workers_started,
+        workers_completed: summary.workers_completed,
+        patch_candidates: summary.patch_candidates,
+        gate_passed_candidates: summary.gate_passed_candidates,
+        mergeable_candidates: summary.mergeable_candidates,
+        applied_patches: summary.applied_patches,
+        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: []
+    };
+    const artifactDir = await writeMissionArtifacts({
+        root: cwd,
+        missionId,
+        workGraph: graph,
+        conflictGraph,
+        mergePlan,
+        ...(judgeResult ? { judgeResult } : {}),
+        workerTraces: traceState.workerTraces,
+        providerHealth: healthTracker.snapshot(),
+        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 },
+        missionResult: result,
+        envelopes
+    });
+    // 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'),
+        terminal: terminalState === 'completed' || terminalState === 'blocked',
+        terminalState,
+        evidence: {
+            build_passed: result.ok,
+            tests_passed: result.ok,
+            route_evidence_passed: result.ok,
+            per_worker_artifacts: true,
+            verifier_wave_run: true,
+            model_guard_enforced: true,
+        },
+        blockers: result.blockers || [],
+        nativeGateFile: 'termination.json',
+    }).catch(() => null);
+    return { ...result, artifact_dir: artifactDir };
+}
+function missionResult(missionId, task, status, reason, patchCandidates, startedMs, envelopes, traces, blockers, warnings) {
+    return {
+        schema: 'sks.glm-naruto-mission-result.v1',
+        ok: status === 'completed',
+        status,
+        mission_id: missionId,
+        task,
+        model: GLM_52_OPENROUTER_MODEL,
+        gpt_fallback_allowed: false,
+        termination_reason: reason,
+        workers_started: traces.length,
+        workers_completed: traces.filter((t) => t.status === 'completed').length,
+        patch_candidates: envelopes.length,
+        gate_passed_candidates: envelopes.filter((e) => e.status === 'gate_passed').length,
+        mergeable_candidates: 0,
+        applied_patches: 0,
+        failed_shards: 0,
+        repair_waves: 0,
+        budget_used_ms: Date.now() - startedMs,
+        blockers,
+        warnings
+    };
+}
+async function readGitStatus(cwd) {
+    const { spawn } = await import('node:child_process');
+    return new Promise((resolve) => {
+        const child = spawn('git', ['status', '--short'], { cwd, stdio: ['ignore', 'pipe', 'ignore'] });
+        let stdout = '';
+        child.stdout.on('data', (chunk) => { stdout += String(chunk); });
+        child.on('close', () => resolve(stdout.trim() || undefined));
+    });
+}
+function extractMentionedPaths(task) {
+    const matches = task.match(/(?:^|\s|[`"'])([A-Za-z0-9_.-]+\/[A-Za-z0-9_./-]+\.[A-Za-z0-9]+)(?:\s|[`"']|$)/g) || [];
+    return [...new Set(matches.map((value) => value.trim().replace(/^[`"']|[`"']$/g, '')))];
+}
+//# sourceMappingURL=glm-naruto-orchestrator.js.map