sneakoscope 2.0.4 → 2.0.6

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

package/dist/core/naruto/naruto-role-policy.js

@@ -0,0 +1,107 @@
+export const NARUTO_WRITE_ROLES = new Set([
+    'implementer',
+    'modifier',
+    'test_writer',
+    'conflict_resolver',
+    'rollback_planner',
+    'integrator'
+]);
+export const NARUTO_IMPLEMENTATION_LIKE_ROLES = new Set([
+    'implementer',
+    'modifier',
+    'test_writer',
+    'conflict_resolver'
+]);
+export function narutoRoleAllowsWrite(role) {
+    return NARUTO_WRITE_ROLES.has(role);
+}
+export function mapWorkKindToNarutoRole(kind) {
+    switch (kind) {
+        case 'implementation':
+            return 'implementer';
+        case 'code_modification':
+        case 'refactor':
+        case 'patch_rebase':
+            return 'modifier';
+        case 'test_generation':
+            return 'test_writer';
+        case 'test_execution':
+        case 'verification':
+        case 'ux_review':
+        case 'ppt_review':
+        case 'image_review':
+            return 'verifier';
+        case 'research':
+            return 'researcher';
+        case 'documentation':
+            return 'modifier';
+        case 'conflict_resolution':
+            return 'conflict_resolver';
+        case 'rollback_preparation':
+            return 'rollback_planner';
+        case 'integration_support':
+            return 'integrator';
+        case 'final_review_input_pack':
+            return 'gpt_final_arbiter';
+    }
+}
+export function mapNarutoRoleToAgentRole(role) {
+    switch (role) {
+        case 'implementer':
+        case 'modifier':
+        case 'test_writer':
+            return 'implementer';
+        case 'researcher':
+            return 'research';
+        case 'conflict_resolver':
+        case 'rollback_planner':
+        case 'integrator':
+        case 'gpt_final_arbiter':
+            return 'integrator';
+        case 'verifier':
+            return 'verifier';
+    }
+}
+export function buildNarutoRoleDistribution(workItems, opts = {}) {
+    const readonly = opts.readonly === true;
+    const counts = new Map();
+    const workItemRoles = workItems.map((item) => {
+        const role = mapWorkKindToNarutoRole(item.kind);
+        counts.set(role, (counts.get(role) || 0) + 1);
+        return {
+            work_item_id: item.id,
+            kind: item.kind,
+            role,
+            write_allowed: item.write_allowed && narutoRoleAllowsWrite(role)
+        };
+    });
+    const entries = [...counts.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([role, count]) => ({
+        role,
+        count,
+        write_allowed: narutoRoleAllowsWrite(role)
+    }));
+    const implementationLikeWorkers = workItemRoles.filter((row) => NARUTO_IMPLEMENTATION_LIKE_ROLES.has(row.role)).length;
+    const totalWorkers = workItems.length;
+    const implementationLikeRatio = totalWorkers ? implementationLikeWorkers / totalWorkers : 0;
+    const verifierOnly = totalWorkers > 0 && workItemRoles.every((row) => row.role === 'verifier');
+    const writeAllowedCount = workItemRoles.filter((row) => row.write_allowed).length;
+    const blockers = [
+        ...(totalWorkers === 0 ? ['naruto_role_distribution_empty'] : []),
+        ...(!readonly && verifierOnly ? ['naruto_default_must_not_be_verifier_only'] : []),
+        ...(!readonly && implementationLikeRatio < 0.4 ? ['naruto_write_capable_route_requires_40_percent_implementation_like_roles'] : []),
+        ...(!readonly && writeAllowedCount === 0 ? ['naruto_write_capable_route_requires_write_roles'] : [])
+    ];
+    return {
+        schema: 'sks.naruto-role-distribution.v1',
+        readonly,
+        total_workers: totalWorkers,
+        implementation_like_workers: implementationLikeWorkers,
+        implementation_like_ratio: Math.round(implementationLikeRatio * 1000) / 1000,
+        verifier_only: verifierOnly,
+        entries,
+        work_item_roles: workItemRoles,
+        ok: blockers.length === 0,
+        blockers
+    };
+}
+//# sourceMappingURL=naruto-role-policy.js.map

package/dist/core/naruto/naruto-verification-dag.js

@@ -0,0 +1,42 @@
+import { buildVerificationDag } from '../verification/verification-dag.js';
+const NODE_KIND_CYCLE = [
+    'typecheck_shard',
+    'unit_test_shard',
+    'route_gate_shard',
+    'lint_static_scan_shard',
+    'schema_validation_shard',
+    'patch_specific_test_shard',
+    'docs_changelog_check',
+    'side_effect_check',
+    'mutation_ledger_check',
+    'zellij_proof_check',
+    'local_llm_structured_output_check'
+];
+export function buildNarutoVerificationDag(graph, input = {}) {
+    const command = input.command || 'node -e "process.exit(0)"';
+    const verifiableItems = graph.work_items.filter((item) => item.verification_required);
+    const taskIdByWorkItemId = new Map(verifiableItems.map((item, index) => [item.id, `NV-${String(index + 1).padStart(6, '0')}`]));
+    const tasks = verifiableItems
+        .map((item, index) => {
+        const kind = NODE_KIND_CYCLE[index % NODE_KIND_CYCLE.length] || 'route_gate_shard';
+        const taskId = taskIdByWorkItemId.get(item.id) || `NV-${String(index + 1).padStart(6, '0')}`;
+        return {
+            id: taskId,
+            command,
+            ...(input.cwd ? { cwd: input.cwd } : {}),
+            inputs: [...item.target_paths],
+            outputs: [`.sneakoscope/reports/naruto-verification/${item.id}.json`],
+            dependencies: item.dependencies.map((dep) => taskIdByWorkItemId.get(dep)).filter((dep) => typeof dep === 'string' && dep !== taskId),
+            timeout_ms: 60000,
+            read_only: true
+        };
+    });
+    const dag = buildVerificationDag(tasks);
+    return {
+        ...dag,
+        naruto_schema: 'sks.naruto-verification-dag.v1',
+        node_kinds: NODE_KIND_CYCLE,
+        starts_when_dependencies_ready: true
+    };
+}
+//# sourceMappingURL=naruto-verification-dag.js.map

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

@@ -0,0 +1,18 @@
+import { runVerificationDag } from '../verification/verification-worker-pool.js';
+export async function runNarutoVerificationPool(dag, governor, opts = {}) {
+    const safeConcurrency = Math.max(1, governor.verification_parallel);
+    const result = await runVerificationDag(dag, {
+        ...(opts.cwd ? { cwd: opts.cwd } : {}),
+        ...(opts.logDir ? { logDir: opts.logDir } : {}),
+        concurrency: safeConcurrency
+    });
+    return {
+        ...result,
+        naruto_schema: 'sks.naruto-verification-pool.v1',
+        safe_concurrency: safeConcurrency,
+        cpu_heavy_cap_respected: safeConcurrency <= Math.max(1, governor.hardware.cpu_core_count * 2),
+        io_heavy_cap_respected: governor.backpressure !== 'saturated',
+        api_rate_cap_respected: safeConcurrency <= Math.max(1, governor.remote_codex_parallel)
+    };
+}
+//# sourceMappingURL=naruto-verification-pool.js.map

package/dist/core/naruto/naruto-work-graph.js

@@ -0,0 +1,198 @@
+import { mapWorkKindToNarutoRole } from './naruto-role-policy.js';
+import { isNarutoWriteKind, normalizeNarutoPath } from './naruto-work-item.js';
+const WRITE_CAPABLE_KIND_CYCLE = [
+    'implementation',
+    'code_modification',
+    'test_generation',
+    'verification',
+    'research',
+    'documentation',
+    'refactor',
+    'test_execution',
+    'conflict_resolution',
+    'patch_rebase',
+    'rollback_preparation',
+    'integration_support',
+    'final_review_input_pack'
+];
+const READONLY_KIND_CYCLE = [
+    'verification',
+    'research',
+    'test_execution',
+    'ux_review',
+    'ppt_review',
+    'image_review',
+    'final_review_input_pack'
+];
+export function buildNarutoWorkGraph(input = {}) {
+    const requestedClones = normalizePositiveInt(input.requestedClones, 12);
+    const readonly = input.readonly === true;
+    const writeCapable = input.writeCapable !== false && !readonly;
+    const totalWorkItems = Math.max(requestedClones, normalizePositiveInt(input.totalWorkItems, requestedClones));
+    const kindCycle = writeCapable ? WRITE_CAPABLE_KIND_CYCLE : READONLY_KIND_CYCLE;
+    const basePath = normalizeNarutoPath(input.leaseBasePath || '.sneakoscope/naruto/patch-envelopes');
+    const targetPaths = normalizePaths(input.targetPaths || []);
+    const readonlyPaths = normalizePaths(input.readonlyPaths || []);
+    const workItems = [];
+    for (let index = 0; index < totalWorkItems; index += 1) {
+        const id = `NW-${String(index + 1).padStart(6, '0')}`;
+        const kind = kindCycle[index % kindCycle.length] || 'verification';
+        const kindWrites = writeCapable && isNarutoWriteKind(kind);
+        const selectedTarget = targetPaths.length ? targetPaths[index % targetPaths.length] || targetPaths[0] || '' : `${basePath}/${id}.json`;
+        const writePaths = kindWrites ? [selectedTarget].filter(Boolean) : [];
+        const readPaths = readonlyPaths.length ? readonlyPaths : targetPaths.filter((item) => !writePaths.includes(item));
+        const leaseRequirements = [
+            ...writePaths.map((file) => ({ path: file, kind: 'write' })),
+            ...readPaths.map((file) => ({ path: file, kind: 'read' }))
+        ];
+        workItems.push({
+            id,
+            kind,
+            title: titleForKind(kind, id),
+            target_paths: [...new Set([...(writePaths.length ? writePaths : [selectedTarget].filter(Boolean)), ...readPaths])],
+            readonly_paths: readPaths,
+            write_paths: writePaths,
+            required_role: mapWorkKindToNarutoRole(kind),
+            write_allowed: writePaths.length > 0,
+            verification_required: kind !== 'research' && kind !== 'final_review_input_pack',
+            dependencies: dependenciesForKind(kind, workItems),
+            can_run_in_parallel_with: [],
+            conflicts_with: [],
+            estimated_cost: estimateCost(kind),
+            lease_requirements: leaseRequirements,
+            acceptance: {
+                requires_patch_envelope: writePaths.length > 0,
+                requires_verification: kind !== 'research' && kind !== 'final_review_input_pack',
+                requires_gpt_final: writePaths.length > 0 || kind === 'final_review_input_pack'
+            }
+        });
+    }
+    const activeWaves = planNarutoWorkWaves(workItems, Math.max(1, normalizePositiveInt(input.maxActiveWorkers, requestedClones)));
+    annotateParallelCompatibility(workItems, activeWaves);
+    const mixedWorkKinds = [...new Set(workItems.map((item) => item.kind))];
+    const writeAllowedCount = workItems.filter((item) => item.write_allowed).length;
+    const blockers = [
+        ...(mixedWorkKinds.length < 2 ? ['naruto_work_graph_not_mixed'] : []),
+        ...(!readonly && writeAllowedCount === 0 ? ['naruto_write_capable_graph_missing_write_items'] : []),
+        ...(workItems.length < requestedClones ? ['naruto_work_graph_below_requested_clones'] : []),
+        ...activeWaves.flatMap((wave) => wave.conflict_count > 0 ? [`naruto_wave_write_conflict:${wave.wave_id}`] : [])
+    ];
+    return {
+        schema: 'sks.naruto-work-graph.v1',
+        route: '$Naruto',
+        requested_clones: requestedClones,
+        total_work_items: workItems.length,
+        readonly,
+        write_capable: writeCapable,
+        work_items: workItems,
+        active_waves: activeWaves,
+        mixed_work_kinds: mixedWorkKinds,
+        write_allowed_count: writeAllowedCount,
+        ok: blockers.length === 0,
+        blockers
+    };
+}
+export function validateNarutoWorkGraph(graph) {
+    const ids = new Set();
+    const blockers = [...graph.blockers];
+    for (const item of graph.work_items) {
+        if (ids.has(item.id))
+            blockers.push(`duplicate_work_item:${item.id}`);
+        ids.add(item.id);
+        for (const dep of item.dependencies) {
+            if (!ids.has(dep) && !graph.work_items.some((candidate) => candidate.id === dep))
+                blockers.push(`missing_dependency:${item.id}:${dep}`);
+        }
+        if (item.write_allowed && item.acceptance.requires_patch_envelope !== true)
+            blockers.push(`write_item_missing_patch_envelope_acceptance:${item.id}`);
+    }
+    if (graph.total_work_items !== graph.work_items.length)
+        blockers.push('naruto_work_graph_count_mismatch');
+    if (!graph.readonly && graph.write_allowed_count === 0)
+        blockers.push('naruto_write_capable_graph_missing_write_items');
+    return { ok: blockers.length === 0, blockers: [...new Set(blockers)] };
+}
+export function planNarutoWorkWaves(items, maxActiveWorkers) {
+    const pending = [...items];
+    const waves = [];
+    while (pending.length) {
+        const waveItems = [];
+        const writePaths = new Set();
+        for (let index = 0; index < pending.length && waveItems.length < maxActiveWorkers;) {
+            const item = pending[index];
+            if (!item) {
+                index += 1;
+                continue;
+            }
+            const conflicts = item.write_paths.some((file) => writePaths.has(file));
+            if (conflicts) {
+                index += 1;
+                continue;
+            }
+            waveItems.push(item);
+            for (const file of item.write_paths)
+                writePaths.add(file);
+            pending.splice(index, 1);
+        }
+        if (!waveItems.length) {
+            const item = pending.shift();
+            if (item)
+                waveItems.push(item);
+        }
+        const paths = waveItems.flatMap((item) => item.write_paths);
+        waves.push({
+            wave_id: `NWAVE-${String(waves.length + 1).padStart(4, '0')}`,
+            work_item_ids: waveItems.map((item) => item.id),
+            write_paths: [...new Set(paths)],
+            conflict_count: paths.length - new Set(paths).size
+        });
+    }
+    return waves;
+}
+function annotateParallelCompatibility(items, waves) {
+    const byId = new Map(items.map((item) => [item.id, item]));
+    for (const wave of waves) {
+        for (const id of wave.work_item_ids) {
+            const item = byId.get(id);
+            if (!item)
+                continue;
+            item.can_run_in_parallel_with = wave.work_item_ids.filter((other) => other !== id);
+            item.conflicts_with = items
+                .filter((other) => other.id !== id && other.write_paths.some((file) => item.write_paths.includes(file)))
+                .map((other) => other.id);
+        }
+    }
+}
+function dependenciesForKind(kind, previous) {
+    if (kind === 'verification' || kind === 'test_execution') {
+        const candidate = [...previous].reverse().find((item) => item.write_allowed);
+        return candidate ? [candidate.id] : [];
+    }
+    if (kind === 'final_review_input_pack') {
+        return previous.slice(-3).map((item) => item.id);
+    }
+    return [];
+}
+function estimateCost(kind) {
+    const heavy = kind === 'implementation' || kind === 'code_modification' || kind === 'refactor' || kind === 'conflict_resolution';
+    return {
+        tokens: heavy ? 8000 : 3000,
+        latency_ms: heavy ? 90000 : 30000,
+        cpu_weight: kind === 'test_execution' || kind === 'verification' ? 2 : 1,
+        memory_mb: heavy ? 512 : 256,
+        gpu_weight: 0
+    };
+}
+function titleForKind(kind, id) {
+    return `${id} ${kind.replace(/_/g, ' ')}`;
+}
+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 normalizePaths(paths) {
+    return [...new Set(paths.map(normalizeNarutoPath).filter(Boolean))];
+}
+//# sourceMappingURL=naruto-work-graph.js.map