sneakoscope 2.0.2 → 2.0.5

package/dist/core/local-llm/local-llm-smoke.js

@@ -0,0 +1,83 @@
+import os from 'node:os';
+import path from 'node:path';
+import { ensureDir, nowIso, sha256, writeJsonAtomic } from '../fsx.js';
+import { detectLocalLlmCapability } from './local-llm-capability.js';
+import { callLocalLlmGenerate, localLlmTokensPerSecond } from './local-llm-client.js';
+import { enforceLocalLlmJsonSchema } from './local-llm-schema-enforcer.js';
+export const LOCAL_LLM_SMOKE_SCHEMA = 'sks.local-llm-smoke.v1';
+export const localLlmSmokeSchema = {
+    type: 'object',
+    required: ['status', 'summary'],
+    properties: {
+        status: { type: 'string' },
+        summary: { type: 'string' }
+    },
+    additionalProperties: false
+};
+export async function runLocalLlmGenerationSmoke(config, opts = {}) {
+    const started = Date.now();
+    const prompt = opts.prompt || 'Return strict JSON: {"status":"ok","summary":"local smoke passed"}';
+    const schema = opts.schema || localLlmSmokeSchema;
+    const capability = await detectLocalLlmCapability(config);
+    const reportPath = expandHome(opts.reportPath || path.join(os.homedir(), '.sneakoscope', 'reports', 'local-llm-smoke.json'));
+    if (!capability.ok) {
+        const smoke = {
+            ok: false,
+            ran_at: nowIso(),
+            prompt_hash: sha256(prompt),
+            latency_ms: Math.max(0, Date.now() - started),
+            tokens_per_second: 0,
+            schema_valid: false,
+            result_path: reportPath,
+            status: 'blocked',
+            blockers: capability.blockers
+        };
+        await writeSmokeReport(reportPath, config, smoke, capability);
+        return smoke;
+    }
+    const request = {
+        model: config.model,
+        prompt,
+        stream: false,
+        format: 'json',
+        think: config.think,
+        keep_alive: config.keep_alive,
+        options: { temperature: 0 }
+    };
+    const response = await callLocalLlmGenerate({ ...config, timeout_ms: opts.timeoutMs || 20_000 }, request);
+    const latencyMs = Math.max(0, Date.now() - started);
+    const enforced = response.ok ? enforceLocalLlmJsonSchema(response.text, schema) : { ok: false, schema_valid: false, issues: [response.error] };
+    const smoke = {
+        ok: response.ok && enforced.ok,
+        ran_at: nowIso(),
+        prompt_hash: sha256(prompt),
+        latency_ms: latencyMs,
+        tokens_per_second: response.ok ? localLlmTokensPerSecond(response.data, response.text, latencyMs) : 0,
+        schema_valid: enforced.schema_valid === true,
+        result_path: reportPath,
+        status: response.ok && enforced.ok ? 'verified' : 'blocked',
+        blockers: [
+            ...(response.ok ? [] : ['local_llm_generate_failed', response.error]),
+            ...(enforced.ok ? [] : ['local_llm_smoke_schema_invalid', ...(enforced.issues || []).map(String)])
+        ]
+    };
+    await writeSmokeReport(reportPath, config, smoke, capability, response.ok ? response.data : null);
+    return smoke;
+}
+async function writeSmokeReport(reportPath, config, smoke, capability, rawResponse = null) {
+    await ensureDir(path.dirname(reportPath));
+    await writeJsonAtomic(reportPath, {
+        schema: LOCAL_LLM_SMOKE_SCHEMA,
+        generated_at: nowIso(),
+        provider: config.provider,
+        model: config.model,
+        endpoint: config.base_url,
+        smoke,
+        capability,
+        raw_response: rawResponse
+    });
+}
+function expandHome(value) {
+    return value.startsWith('~/') ? path.join(os.homedir(), value.slice(2)) : value;
+}
+//# sourceMappingURL=local-llm-smoke.js.map

package/dist/core/local-llm/local-llm-warmup.js

@@ -0,0 +1,20 @@
+import { nowIso } from '../fsx.js';
+export function buildLocalLlmWarmupState(config, input) {
+    const ttlMs = Math.max(1, Number(input.ttlMs || 10 * 60 * 1000));
+    const warmedAt = nowIso();
+    return {
+        schema: 'sks.local-llm-warmup-state.v1',
+        ok: input.ok,
+        provider: config.provider,
+        model: config.model,
+        endpoint: config.base_url,
+        warmed_at: warmedAt,
+        expires_at: new Date(Date.parse(warmedAt) + ttlMs).toISOString(),
+        explicit_only: true,
+        postinstall_allowed: false,
+        release_check_real_warmup_allowed: false,
+        release_real_check_requires_env: 'SKS_REQUIRE_LOCAL_LLM=1',
+        reason: input.reason || null
+    };
+}
+//# sourceMappingURL=local-llm-warmup.js.map

package/dist/core/local-llm/local-worker-eligibility.js

@@ -0,0 +1,27 @@
+export function evaluateLocalWorkerEligibility(input, config) {
+    const prompt = String(input.prompt || '');
+    const writePaths = Array.isArray(input.requestedScopeContract?.write_paths) ? input.requestedScopeContract.write_paths.map(String) : [];
+    const forbidden = /\b(strategy|planning|architecture|design|final review|verification authority|safety authority|integration|database|migration|permission approval)\b/i.test(prompt);
+    const allowed = /\b(worker|patch|read-only|grep|qa|test|docstring|summary|refactor)\b/i.test(`${input.route} ${prompt}`);
+    const blockers = [
+        ...(config.enabled ? [] : ['local_llm_disabled']),
+        ...(config.status === 'verified' ? [] : [`local_llm_${config.status}`]),
+        ...(input.tier === 'worker' ? [] : ['local_llm_worker_tier_only']),
+        ...(input.sandboxPolicy === 'full-access' ? ['local_llm_full_access_blocked'] : []),
+        ...(input.localLlmPolicy?.requiresGptFinal === false ? ['local_llm_requires_gpt_final_policy_missing'] : []),
+        ...(forbidden ? ['local_llm_forbidden_task_class'] : []),
+        ...(!allowed && !writePaths.length ? ['local_llm_task_not_eligible'] : [])
+    ];
+    return {
+        schema: 'sks.local-worker-eligibility.v1',
+        ok: blockers.length === 0,
+        task_classes: {
+            allowed_detected: allowed,
+            forbidden_detected: forbidden,
+            write_path_count: writePaths.length
+        },
+        requires_gpt_final: true,
+        blockers
+    };
+}
+//# sourceMappingURL=local-worker-eligibility.js.map

package/dist/core/naruto/hardware-capacity-probe.js

@@ -0,0 +1,36 @@
+import os from 'node:os';
+export function probeHardwareCapacity(input = {}) {
+    const memory = process.memoryUsage();
+    return {
+        schema: 'sks.naruto-hardware-capacity-probe.v1',
+        cpu_core_count: normalizePositiveInt(input.cores, os.cpus()?.length || 1),
+        current_load_average: input.loadAverage || os.loadavg(),
+        free_memory_bytes: normalizePositiveInt(input.freeMemoryBytes, os.freemem()),
+        total_memory_bytes: normalizePositiveInt(input.totalMemoryBytes, os.totalmem()),
+        node_heap_used_bytes: normalizePositiveInt(input.nodeHeapUsedBytes, memory.heapUsed),
+        node_heap_total_bytes: normalizePositiveInt(input.nodeHeapTotalBytes, memory.heapTotal),
+        process_count: normalizePositiveInt(input.processCount, 1),
+        file_descriptor_limit: normalizePositiveInt(input.fileDescriptorLimit, Number(process.env.SKS_NARUTO_FD_LIMIT) || 256),
+        zellij_pane_count: normalizeNonNegativeInt(input.zellijPaneCount, 0),
+        terminal_columns: normalizePositiveInt(input.terminalColumns, process.stdout.columns || 120),
+        terminal_rows: normalizePositiveInt(input.terminalRows, process.stdout.rows || 40),
+        local_llm_max_parallel_requests: normalizePositiveInt(input.localLlmMaxParallelRequests, Number(process.env.SKS_LOCAL_LLM_MAX_PARALLEL_REQUESTS) || 4),
+        remote_api_rate_limit_budget: normalizePositiveInt(input.remoteApiRateLimitBudget, Number(process.env.SKS_REMOTE_API_PARALLEL_BUDGET) || 12),
+        gpu_available: input.gpuAvailable === true,
+        gpu_vram_mb: normalizeNonNegativeInt(input.gpuVramMb, 0),
+        disk_io_pressure: Math.max(0, Math.min(1, Number(input.diskIoPressure ?? 0)))
+    };
+}
+function normalizePositiveInt(value, fallback) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 1)
+        return Math.max(1, Math.floor(fallback));
+    return Math.floor(parsed);
+}
+function normalizeNonNegativeInt(value, fallback) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 0)
+        return Math.max(0, Math.floor(fallback));
+    return Math.floor(parsed);
+}
+//# sourceMappingURL=hardware-capacity-probe.js.map

package/dist/core/naruto/naruto-active-pool.js

@@ -0,0 +1,118 @@
+import { createNarutoGeneration, completeNarutoGeneration } from './naruto-generation-scheduler.js';
+export function simulateNarutoActivePool(input) {
+    const safeActiveWorkers = Math.max(1, input.governor.safe_active_workers);
+    const retryLimit = Math.max(0, Math.floor(Number(input.retryLimit ?? 1)));
+    const failIds = new Set((input.failWorkItemIds || []).map(String));
+    const pending = [...input.graph.work_items];
+    const active = new Map();
+    const completed = new Set();
+    const failed = new Set();
+    const executed = new Map();
+    const timeline = [];
+    let generationIndex = 1;
+    let tick = 0;
+    let refillEvents = 0;
+    let maxObserved = 0;
+    let conflictItemsEnqueued = 0;
+    while (pending.length || active.size) {
+        let launched = 0;
+        for (;;) {
+            if (active.size >= safeActiveWorkers)
+                break;
+            const next = popRunnable(pending, completed, active);
+            if (!next)
+                break;
+            const generation = createNarutoGeneration(next, generationIndex, tick);
+            generationIndex += 1;
+            active.set(generation.generation_id, generation);
+            executed.set(next.id, (executed.get(next.id) || 0) + 1);
+            launched += 1;
+        }
+        if (launched)
+            refillEvents += launched;
+        maxObserved = Math.max(maxObserved, active.size);
+        timeline.push({ tick, active: active.size, pending: pending.length, completed: completed.size, event: launched ? 'refill' : 'wait' });
+        const done = [...active.values()].slice(0, Math.max(1, Math.ceil(active.size / 2)));
+        if (!done.length && pending.length)
+            break;
+        for (const generation of done) {
+            active.delete(generation.generation_id);
+            const shouldFail = failIds.has(generation.work_item_id) && (executed.get(generation.work_item_id) || 0) <= retryLimit;
+            completeNarutoGeneration(generation, tick + 1, shouldFail);
+            if (shouldFail) {
+                failed.add(generation.work_item_id);
+                conflictItemsEnqueued += 1;
+                pending.push(conflictResolutionFollowup(generation.work_item_id, input.graph.work_items.length + conflictItemsEnqueued));
+            }
+            else {
+                completed.add(generation.work_item_id);
+            }
+        }
+        tick += 1;
+        if (tick > input.graph.work_items.length * 4 + 20)
+            break;
+    }
+    const duplicateExecutionCount = [...executed.values()].filter((count) => count > 1).length;
+    const blockers = [
+        ...(pending.length ? ['naruto_active_pool_pending_not_drained'] : []),
+        ...(active.size ? ['naruto_active_pool_active_not_drained'] : []),
+        ...(maxObserved > safeActiveWorkers ? ['naruto_active_pool_exceeded_safe_workers'] : []),
+        ...(duplicateExecutionCount > conflictItemsEnqueued ? ['naruto_active_pool_duplicate_execution_without_retry'] : [])
+    ];
+    return {
+        schema: 'sks.naruto-active-pool.v1',
+        ok: blockers.length === 0,
+        safe_active_workers: safeActiveWorkers,
+        total_work_items: input.graph.total_work_items,
+        completed_count: completed.size,
+        failed_count: failed.size,
+        refill_events: refillEvents,
+        max_observed_active_workers: maxObserved,
+        duplicate_execution_count: duplicateExecutionCount,
+        conflict_items_enqueued: conflictItemsEnqueued,
+        timeline,
+        blockers
+    };
+}
+function popRunnable(pending, completed, active) {
+    const activeWorkIds = new Set([...active.values()].map((item) => item.work_item_id));
+    for (let index = 0; index < pending.length; index += 1) {
+        const item = pending[index];
+        if (!item)
+            continue;
+        if (activeWorkIds.has(item.id))
+            continue;
+        if (!item.dependencies.every((dep) => completed.has(dep)))
+            continue;
+        const writeConflict = [...active.values()].some((generation) => {
+            const activeItem = pending.find((candidate) => candidate.id === generation.work_item_id);
+            return activeItem?.write_paths.some((file) => item.write_paths.includes(file));
+        });
+        if (writeConflict)
+            continue;
+        pending.splice(index, 1);
+        return item;
+    }
+    return null;
+}
+function conflictResolutionFollowup(failedId, index) {
+    const id = `NW-CONFLICT-${String(index).padStart(4, '0')}`;
+    return {
+        id,
+        kind: 'conflict_resolution',
+        title: `Resolve failed work item ${failedId}`,
+        target_paths: [],
+        readonly_paths: [],
+        write_paths: [`.sneakoscope/naruto/conflicts/${id}.json`],
+        required_role: 'conflict_resolver',
+        write_allowed: true,
+        verification_required: true,
+        dependencies: [],
+        can_run_in_parallel_with: [],
+        conflicts_with: [],
+        estimated_cost: { tokens: 4000, latency_ms: 45000, cpu_weight: 1, memory_mb: 256, gpu_weight: 0 },
+        lease_requirements: [{ path: `.sneakoscope/naruto/conflicts/${id}.json`, kind: 'write' }],
+        acceptance: { requires_patch_envelope: true, requires_verification: true, requires_gpt_final: true }
+    };
+}
+//# sourceMappingURL=naruto-active-pool.js.map

package/dist/core/naruto/naruto-backpressure.js

@@ -0,0 +1,13 @@
+export function applyNarutoBackpressure(requestedActiveWorkers, pressure) {
+    const requested = Math.max(1, Math.floor(requestedActiveWorkers));
+    const multiplier = pressure.state === 'saturated' ? 0.25 : pressure.state === 'throttled' ? 0.5 : 1;
+    const adjusted = Math.max(1, Math.floor(requested * multiplier));
+    return {
+        schema: 'sks.naruto-backpressure.v1',
+        requested_active_workers: requested,
+        adjusted_active_workers: adjusted,
+        backpressure: pressure.state,
+        reasons: pressure.reasons
+    };
+}
+//# sourceMappingURL=naruto-backpressure.js.map

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

@@ -0,0 +1,65 @@
+import { probeHardwareCapacity } from './hardware-capacity-probe.js';
+import { applyNarutoBackpressure } from './naruto-backpressure.js';
+import { monitorNarutoResourcePressure } from './resource-pressure-monitor.js';
+export function decideNarutoConcurrency(input = {}) {
+    const requestedClones = normalizePositiveInt(input.requestedClones, 12);
+    const totalWorkItems = normalizePositiveInt(input.totalWorkItems, requestedClones);
+    const pending = normalizeNonNegativeInt(input.pendingWorkQueueSize, totalWorkItems);
+    const leaseConflicts = normalizeNonNegativeInt(input.activeLeaseConflicts, 0);
+    const hardware = probeHardwareCapacity(input.hardware || {});
+    const zellijVisiblePaneCap = normalizePositiveInt(input.zellijVisiblePaneCap, Math.min(12, Math.max(4, Math.floor(hardware.terminal_rows / 3))));
+    const backend = String(input.backend || 'codex-sdk');
+    const freeGb = hardware.free_memory_bytes / (1024 * 1024 * 1024);
+    const totalGb = hardware.total_memory_bytes / (1024 * 1024 * 1024);
+    const reclaimableFloorGb = totalGb >= 32 ? 16 : totalGb >= 16 ? 8 : totalGb >= 8 ? 4 : Math.max(1, freeGb);
+    const memoryBudgetGb = Math.max(freeGb, reclaimableFloorGb);
+    const heavy = backend === 'codex-sdk' || backend === 'zellij' || backend === 'process' || backend === 'ollama';
+    const gbPerWorker = heavy ? Number(process.env.SKS_NARUTO_GB_PER_WORKER || 0.25) : Number(process.env.SKS_NARUTO_LIGHT_GB_PER_WORKER || 0.1);
+    const memoryCap = Math.max(1, Math.floor(memoryBudgetGb / Math.max(0.05, gbPerWorker)));
+    const fdCap = Math.max(1, Math.floor((hardware.file_descriptor_limit - hardware.process_count) / 6));
+    const localLlmParallel = Math.max(1, Math.min(4, hardware.local_llm_max_parallel_requests));
+    const remoteCodexParallel = Math.max(1, Math.min(hardware.remote_api_rate_limit_budget, requestedClones));
+    const queueCap = Math.max(1, Math.min(requestedClones, pending || totalWorkItems));
+    const leaseCap = Math.max(1, requestedClones - leaseConflicts);
+    const rawSafe = Math.max(1, Math.min(requestedClones, totalWorkItems, memoryCap, fdCap, remoteCodexParallel, queueCap, leaseCap, 100));
+    const pressure = monitorNarutoResourcePressure(hardware, { activeWorkers: rawSafe, zellijVisiblePaneCap });
+    const backpressure = applyNarutoBackpressure(rawSafe, pressure);
+    const safeActiveWorkers = Math.max(1, Math.min(rawSafe, backpressure.adjusted_active_workers));
+    const safeVisible = Math.min(safeActiveWorkers, zellijVisiblePaneCap);
+    const reasons = [
+        ...(memoryCap < requestedClones ? ['memory_cap'] : []),
+        ...(fdCap < requestedClones ? ['file_descriptor_budget'] : []),
+        ...(remoteCodexParallel < requestedClones ? ['remote_api_rate_limit_budget'] : []),
+        ...(localLlmParallel <= 4 ? ['local_llm_max_parallel_requests'] : []),
+        ...(safeVisible < safeActiveWorkers ? ['zellij_ui_pane_budget'] : []),
+        ...(leaseConflicts > 0 ? ['active_lease_conflicts'] : []),
+        ...pressure.reasons
+    ];
+    return {
+        schema: 'sks.naruto-concurrency-governor.v1',
+        requested_clones: requestedClones,
+        total_work_items: totalWorkItems,
+        safe_active_workers: safeActiveWorkers,
+        safe_zellij_visible_panes: safeVisible,
+        headless_workers: Math.max(0, safeActiveWorkers - safeVisible),
+        local_llm_parallel: localLlmParallel,
+        remote_codex_parallel: remoteCodexParallel,
+        verification_parallel: Math.max(1, Math.min(hardware.cpu_core_count * 2, safeActiveWorkers, 16)),
+        reasons: [...new Set(reasons)],
+        backpressure: backpressure.backpressure,
+        hardware
+    };
+}
+function normalizePositiveInt(value, fallback) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 1)
+        return Math.max(1, Math.floor(fallback));
+    return Math.floor(parsed);
+}
+function normalizeNonNegativeInt(value, fallback) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 0)
+        return Math.max(0, Math.floor(fallback));
+    return Math.floor(parsed);
+}
+//# sourceMappingURL=naruto-concurrency-governor.js.map

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

@@ -0,0 +1,18 @@
+export function evaluateNarutoFinalizer(input = {}) {
+    const localParticipated = input.localParticipated === true;
+    const gptFinalRequired = localParticipated;
+    const gptFinalAccepted = input.gptFinalStatus === 'approved' || input.gptFinalStatus === 'modified';
+    const blockers = [
+        ...(gptFinalRequired && !gptFinalAccepted ? ['naruto_local_worker_output_needs_gpt_final_arbiter'] : [])
+    ];
+    return {
+        schema: 'sks.naruto-finalizer.v1',
+        local_participated: localParticipated,
+        gpt_final_required: gptFinalRequired,
+        final_status: blockers.length ? 'blocked' : input.applyPatches === true ? 'accepted' : 'draft',
+        final_patch_source: gptFinalRequired ? 'gpt_final_arbiter' : 'deterministic_no_local',
+        blockers,
+        ok: blockers.length === 0
+    };
+}
+//# sourceMappingURL=naruto-finalizer.js.map

package/dist/core/naruto/naruto-generation-scheduler.js

@@ -0,0 +1,18 @@
+export function createNarutoGeneration(workItem, index, tick) {
+    return {
+        generation_id: `NG-${String(index).padStart(6, '0')}`,
+        work_item_id: workItem.id,
+        role: workItem.required_role,
+        status: 'active',
+        started_tick: tick,
+        completed_tick: null
+    };
+}
+export function completeNarutoGeneration(generation, tick, failed = false) {
+    return {
+        ...generation,
+        status: failed ? 'failed' : 'completed',
+        completed_tick: tick
+    };
+}
+//# sourceMappingURL=naruto-generation-scheduler.js.map

package/dist/core/naruto/naruto-gpt-final-pack.js

@@ -0,0 +1,49 @@
+export function buildNarutoGptFinalPack(input) {
+    const maxPatchEnvelopes = Math.max(1, Math.floor(Number(input.maxPatchEnvelopes || 100)));
+    const maxLogs = Math.max(1, Math.floor(Number(input.maxLogs || 12)));
+    return {
+        schema: 'sks.naruto-gpt-final-pack.v1',
+        mission_id: input.missionId,
+        route: '$Naruto',
+        work_graph_summary: {
+            total_work_items: input.graph.total_work_items,
+            mixed_work_kinds: input.graph.mixed_work_kinds,
+            write_allowed_count: input.graph.write_allowed_count
+        },
+        role_distribution: input.roleDistribution,
+        changed_files: [...new Set((input.changedFiles || []).map(String))],
+        patch_envelopes: (input.patchEnvelopes || []).slice(0, maxPatchEnvelopes).map(redactSecrets),
+        verification_results: (input.verificationResults || []).slice(0, 200).map(redactSecrets),
+        failed_shards: (input.failedShards || []).slice(0, 100).map(redactSecrets),
+        conflict_map: (input.conflictMap || []).slice(0, 100).map(redactSecrets),
+        rollback_plan: redactSecrets(input.rollbackPlan || { status: 'not_required' }),
+        side_effect_report: redactSecrets(input.sideEffectReport || { status: 'not_recorded' }),
+        local_llm_metrics: redactSecrets(input.localLlmMetrics || { participated: false }),
+        representative_logs: (input.logs || []).slice(0, maxLogs).map((log) => redactSecretText(log).slice(-4000)),
+        bounded: true,
+        secrets_redacted: true
+    };
+}
+export function redactSecrets(value) {
+    if (typeof value === 'string')
+        return redactSecretText(value);
+    if (Array.isArray(value))
+        return value.map(redactSecrets);
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [key, item] of Object.entries(value)) {
+            if (/token|secret|password|api[_-]?key|authorization/i.test(key))
+                out[key] = '[REDACTED]';
+            else
+                out[key] = redactSecrets(item);
+        }
+        return out;
+    }
+    return value;
+}
+function redactSecretText(value) {
+    return String(value)
+        .replace(/sk-[A-Za-z0-9_-]{16,}/g, 'sk-[REDACTED]')
+        .replace(/(api[_-]?key|authorization|token|password)\s*[:=]\s*\S+/gi, '$1=[REDACTED]');
+}
+//# sourceMappingURL=naruto-gpt-final-pack.js.map

package/dist/core/naruto/naruto-parallel-patch-apply.js

@@ -0,0 +1,95 @@
+import path from 'node:path';
+import { normalizeAgentPatchEnvelope, validateAgentPatchEnvelope } from '../agents/agent-patch-schema.js';
+import { ensureDir, readText, sha256, writeTextAtomic } from '../fsx.js';
+import { envelopeIdFor, planNarutoPatchTransactionBatches } from './naruto-patch-transaction-batch.js';
+export async function applyNarutoPatchEnvelopes(root, rawEnvelopes, opts = {}) {
+    const dryRun = opts.dryRun === true;
+    const envelopes = rawEnvelopes.map(normalizeAgentPatchEnvelope);
+    const plan = planNarutoPatchTransactionBatches(envelopes);
+    const results = [];
+    for (const batch of plan.batches) {
+        const batchEnvelopes = envelopes.filter((envelope) => batch.envelope_ids.includes(envelopeIdFor(envelope)));
+        const batchResults = await Promise.all(batchEnvelopes.map((envelope) => applyEnvelope(root, envelope, dryRun)));
+        results.push(...batchResults);
+    }
+    const blockers = [
+        ...plan.conflicts.map((conflict) => `naruto_patch_conflict:${conflict.envelope_id}`),
+        ...results.flatMap((result) => result.blockers)
+    ];
+    return {
+        schema: 'sks.naruto-parallel-patch-apply.v1',
+        ok: blockers.length === 0,
+        dry_run: dryRun,
+        batch_count: plan.batches.length,
+        parallel_apply_count: plan.batches.filter((batch) => batch.envelope_ids.length > 1).length,
+        conflicts: plan.conflicts,
+        results,
+        blockers
+    };
+}
+async function applyEnvelope(root, envelope, dryRun) {
+    const validation = validateAgentPatchEnvelope(envelope);
+    const beforeHashes = {};
+    const afterHashes = {};
+    const rollback = [];
+    const changedFiles = [];
+    const blockers = [...validation.violations];
+    if (!validation.ok) {
+        return { envelope_id: envelopeIdFor(envelope), ok: false, changed_files: [], before_hashes: {}, after_hashes: {}, rollback: [], blockers };
+    }
+    for (const operation of envelope.operations) {
+        const target = resolvePatchPath(root, operation.path);
+        const before = await readText(target, '');
+        beforeHashes[operation.path] = sha256(String(before));
+        rollback.push({ path: operation.path, content: String(before) });
+        const after = applyOperation(String(before), operation);
+        afterHashes[operation.path] = sha256(after);
+        if (after !== before) {
+            changedFiles.push(operation.path);
+            if (!dryRun) {
+                await ensureDir(path.dirname(target));
+                await writeTextAtomic(target, after);
+            }
+        }
+    }
+    return {
+        envelope_id: envelopeIdFor(envelope),
+        ok: blockers.length === 0,
+        changed_files: changedFiles,
+        before_hashes: beforeHashes,
+        after_hashes: afterHashes,
+        rollback,
+        blockers
+    };
+}
+export async function rollbackNarutoPatchResult(root, result) {
+    const restored = [];
+    const blockers = [];
+    for (const entry of result.rollback) {
+        try {
+            const target = resolvePatchPath(root, entry.path);
+            await ensureDir(path.dirname(target));
+            await writeTextAtomic(target, entry.content);
+            restored.push(entry.path);
+        }
+        catch (error) {
+            blockers.push(error instanceof Error ? error.message : String(error));
+        }
+    }
+    return { ok: blockers.length === 0, restored, blockers };
+}
+function applyOperation(before, operation) {
+    if (operation.op === 'write')
+        return String(operation.content || '');
+    if (operation.op === 'replace')
+        return before.replace(String(operation.search || ''), String(operation.replace || ''));
+    return before;
+}
+function resolvePatchPath(root, relativePath) {
+    const resolved = path.resolve(root, relativePath);
+    const base = path.resolve(root);
+    if (resolved !== base && !resolved.startsWith(base + path.sep))
+        throw new Error(`patch path escapes root: ${relativePath}`);
+    return resolved;
+}
+//# sourceMappingURL=naruto-parallel-patch-apply.js.map

package/dist/core/naruto/naruto-patch-transaction-batch.js

@@ -0,0 +1,42 @@
+export function planNarutoPatchTransactionBatches(envelopes) {
+    const batches = [];
+    const conflicts = [];
+    for (const envelope of envelopes) {
+        const envelopeId = envelopeIdFor(envelope);
+        const paths = envelope.operations.map((operation) => operation.path);
+        let placed = false;
+        for (const batch of batches) {
+            const overlaps = paths.filter((file) => batch.write_paths.includes(file));
+            if (overlaps.length)
+                continue;
+            batch.envelope_ids.push(envelopeId);
+            batch.write_paths.push(...paths);
+            batch.write_paths = [...new Set(batch.write_paths)];
+            placed = true;
+            break;
+        }
+        if (!placed) {
+            const previousConflicts = envelopes
+                .filter((candidate) => envelopeIdFor(candidate) !== envelopeId)
+                .filter((candidate) => candidate.operations.some((operation) => paths.includes(operation.path)))
+                .map(envelopeIdFor);
+            if (previousConflicts.length)
+                conflicts.push({ envelope_id: envelopeId, conflicts_with: previousConflicts, write_paths: paths });
+            batches.push({
+                batch_id: `NPB-${String(batches.length + 1).padStart(4, '0')}`,
+                envelope_ids: [envelopeId],
+                write_paths: [...new Set(paths)],
+                parallel_apply_allowed: true
+            });
+        }
+    }
+    return {
+        schema: 'sks.naruto-patch-transaction-batch.v1',
+        batches,
+        conflicts
+    };
+}
+export function envelopeIdFor(envelope) {
+    return `${envelope.agent_id}:${envelope.session_id}:${envelope.task_slice_id || envelope.generation_index}`;
+}
+//# sourceMappingURL=naruto-patch-transaction-batch.js.map